Java方法和数组
方法
什么是方法
Java方法是语句的集合,它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建,在其他地方被引用设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法的原子性,就是一个方法只完成1个功能,这样利于我们后期的扩展。
方法的定义
Java的方法类似于其它语言的函数,是一段用于完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
修饰符:修饰符,这是可以选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型:方法可能会返回值,returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType 是关键字void。
方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
- 形式参数:在方法被调用时用于接收外界输入的数据。
- 实参:调用方法时实际传给方法的数据。
方法体:方法体包含具体的语句,定义该方法的功能。
修饰符 返回值类型 方法名 (参数类型 参数名){
...
方法体
...
return 返回值;
}
方法的调用
调用方法:对象名.方法名(实参列表)
Java 支持两种调用方法的方式,根据方法是否返回值来选择。
当方法返回一个值的时候,方法调用通常被当做一个值。例如:int max = max(20,30);
如果方法返回值是 void ,方法调用一定是一条语句。System.out.println("Hello");
注意: 值传递(Java)和引用传递:
值传递: 使用两个不同的存储单元,执行中,形式参数值改变不会影响实际参数值。
引用传递: 实际为引用地址,实际参数和形式参数指向同一地址,执行中形式参数会影响实际参数。
方法的重载
重载就是在一个类中,有相同的函数名称,但形参不同的函数。
方法重载的规则:
- 方法名称必须相同。
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
实现理论:
方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。
命令行传参
有时候你希望运行一个程序时候再传递给他消息。这要靠传递命令行参数给main()函数实现。
public static void main(String[] args){
for(int i = 0; i < args.length; i++){
System.out.println("args[" + i +"]:" + args[i]);
}
}
注意:
先编译:在类的文件夹下直接javac 类名.java
在运行:一定要在src目录下才能运行java 包名.类名 参数(1 2 3)
可变参数
JDK1.5开始,Java支持传递同类型的可变参数给一个方法。(本质就是数组)
在方法声明中,在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public static void main(String[] args) {
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax(double... numbers){
if (numbers.length ==0){
System.out.println("No argument passed");
return;
}
double result = numbers[0];
//排序
for (int i = 1; i < numbers.length; i++){
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
递归
递归就是:A 方法调用 A 方法!就是自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解决过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分:
- 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身方法。
递归适合小量计算,如果太大量计算容易内存崩溃,死机。【栈机制】(尽量不用递归)
例题:求N的阶乘
public static void main(String[] args){
System.out.println(f(5));
}
// n的阶乘
public static int f(int n){
if (n == 1){
return 1;
}else {
return n * f(n-1);
}
}
数组
数组的定义
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
- 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。
数组的声明和创建
首先必须声明数组变量,才能在程序中使用数组。
声明数组变量的语法:
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同,但不是首选方法
Java 语言使用 new 操作符来创建数组,语法:
dataType[] arrayRefVar = new dataType[arraySize];
数组的元素是通过索引访问的,数组索引从0开始
获取数组长度:
arrays.length
内存分析
Java内存分析:
三种初始化
- 静态初始化
//静态初始化:创建 + 赋值
int[] a = {1, 2, 3};
- 动态初始化
//动态初始化:包含默认初始化,未赋值前有默认值。
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
数组的默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方法被隐式初始化。
数组的四个基本特点
其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型,包括基本类型和引用类型。
数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
数组边界
- 下标的合法区间:[0,length-1],如果越界就会报错;
public static void main(String[] args){
int[] a=new int[2]; //a长度为2,下标表示为a[0],a[1]。
System.out.println(a[2]);//a[2]以超出设定值:出现异常->ArraylndexOutOfBoundsException:数组下标越界异常!
}
ArraylndexOutOfBoundsException
:数组下标越界异常!
小结:
- 数组是相同数据类型(数据类型可以为任意类型)的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度的确定的,不可变的。如果越界,则报:ArrayindexOutofBoundsException
数组的使用
普通的For循环
For-Each 循环
数组作方法入参
数组作返回值
例题:
public static void main(String[] args) {
int[] arrays = {11,12,13,14,15};
//打印全部的数组元素
for (int i = 0; i < arrays.length; i++){
System.out.println(arrays[i]);
}
System.out.println("====================");
//打印数组元素之和
int sum = 0;
for (int i = 0; i < arrays.length; i++){
sum = sum + arrays[i];
}
System.out.println("sum=" + sum);
System.out.println("=================");
//查找数组内最大元素
int max = arrays[0] ;
for (int i = 1; i < arrays.length; i++){
if (max < arrays[i]){
max = arrays[i];
}
}
System.out.println("max=" + max);
}
public static void main(String[] args) {
int[] arrays ={1, 2, 3, 4, 5};
//JDK1.5 没有下标
for (int array : arrays) {
System.out.print(array + " ");
}
System.out.println();
System.out.println("打印数组");
printArray(arrays);
System.out.println("反转数组:");
int[] reverse= reverse(arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
int[] reverse =new int[arrays.length];
for (int i = 0, j = reverse.length-1; i <arrays.length; i++, j--){
reverse[j] = arrays[i];
}
return reverse;
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i <arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
多维数组
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。
二维数组
int a[][] =new int[2][5];
这个二维数组 a 可以看成一个两行五列的数组。
例题:
public static void main(String[] args) {
int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
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.uti.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但是 API 中提供了一个工具类 Arrays 供我们使用,从而可以对数据对象进行一些基本的操作。
Arrays 类中的方法都是
static
修饰的静态方法,在使用的时候可以直接使用类名进行调用,而“不用”使用对象来调用(注意:是“不用”而不是“不能”)
具有以下常用功能:
1、给数组赋值:通过 fill 方法。
2、对数组排序:通过 sort 方法,按升序。
3、比较数据:通过 equals 方法比较数组中元素值是否相等。
4、查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
public static void main(String[] args) {
int[] a = {3, 54, 8, 2, 9, 6, 57, 12, 87};
//打印数组元素,Arrays.toString
System.out.println(Arrays.toString(a));
//数组排序操作
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//数组填充
Arrays.fill(a, 7);
System.out.println(Arrays.toString(a));
//选择填充 [2, 6)
Arrays.fill(a, 2, 6, 0);
System.out.println(Arrays.toString(a));
}
冒泡排序
冒泡排序无疑是最为出名的排序算法之一,总共有八大排序!
冒泡的代码还是相当简单的,两层循环,外层冒泡轮数,里层依次比较,江湖中人人尽皆知。
我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n^2)。
public static void main(String[] args) {
int[] a = {23, 5, 6, 76, 8, 1, 2, 9, 34, 76};
int[] sort = sort(a);
System.out.println(Arrays.toString(a));
}
public static int[] sort(int[] array){
int temp = 0;
boolean flag = false;
for (int i = 0; i <array.length-1 ; i++) { // 最大外循环,判断要走多少次
for (int j = 0; j <array.length-1-i ; j++) { // 排序循环,比较大小,交换位置
if (array[j+1] < array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
if (flag == false){//优化,提前结束。
break;
}
}
}
return array;
}
稀疏数组(压缩)
需求:编写五子棋游戏中,有存盘退出或续上盘的功能。
分析问题:因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据。
解决:稀疏数组
介绍:
当一个数组中大部分元素为0,或者为同一值得数组时,可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是:
- 记录数组一共有几行几列,有多少个不同值。
- 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
如下图:左边是原始数组,右边是稀疏数组
public static void main(String[] args) {
int[][] array1 = new int[11][11];//0代表空,1代表黑子,2代表白子
array1[1][2] = 1;//给黑子定位
array1[2][3] = 2;//给白子定位
//输出原始数据
System.out.println("原始数据:");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + " ");
}
System.out.println();
}
System.out.println("======================");
//转换为稀疏数组保存
//1.求和有效值的个数
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1.length; j++) {
if (array1[i][j] != 0){
sum++;
}
}
}
System.out.println("稀疏数组:");
//2.创建一个稀疏数组的数组
int[][] array2 = new int [sum+1][3];//确定第一条稀疏数组的数据
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//3.将非零的值,存放在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
System.out.println("序 "+" 行 "+" 列 "+" 值 ");//打印数组
int xu = 0;
for (int[] ints : array2) {
System.out.print(xu+" ");
for (int anInt : ints) {
if (anInt<10) {
System.out.print(" " + anInt + " ");
} else {
System.out.print(" " + anInt + " ");
}
}
xu++;
System.out.println();
}
/*
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+ array2[i][1] + "\t"
+ array2[i][2] + "\t");
}*/
System.out.println("========================");
//转换成原始数据
System.out.println("还原原始数组:");
int[][] array3 = new int[array2[0][0]][array2[0][1]];//确认原始数组整体大小
for (int i = 1; i <array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];//将数组的数据赋值
}
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + " ");
}
System.out.println();
}
}
Java方法和数组的更多相关文章
- Java方法调用数组,是否改变原数组元素的总结
Java方法调用数组,是否改变原数组元素的总结 //个人理解, 欢迎吐槽 注意String是引用型变量, 我的理解也就是指向型, 指向一个数据或变量, 画图理解最容易, string 指向的 数据的值 ...
- 067 01 Android 零基础入门 01 Java基础语法 08 Java方法 05 数组作为方法参数
067 01 Android 零基础入门 01 Java基础语法 08 Java方法 05 数组作为方法参数 本文知识点:数组作为方法参数 说明:因为时间紧张,本人写博客过程中只是对知识点的关键步骤进 ...
- Java 方法与数组
方法 什么是方法? 方法定义:方法(Method),函数(function),其实就指一个特定的功能操作,程序中完成独立功能,可重复使用的一段代码的集合. 方法的定义 方法定义格式: [修饰符] 返回 ...
- Java方法_数组
/* 方法:完成特定功能的代码块. 注意:在很多语言里面有函数的定义,而在Java中函数被称为方法. 方法格式: 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) { ...
- [原创]java WEB学习笔记59:Struts2学习之路---OGNL,值栈,读取对象栈中的对象的属性,读取 Context Map 里的对象的属性,调用字段和方法,数组,list,map
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- wrong number of arguments,java方法反射时数组参数的坑
java方法中只有一个参数是数组,反射的时候我们不能想当然的传歌数组进去,传数组进去的时候表示多个参数. 两个数组不是一个意思啊. 我们应该把数组转为objet,这样才表示一个参数. import j ...
- Java方法-数组
[Java数组] 1. 用sort()方法对Java数组进行排序,及如何使用 binarySearch() 方法来查找数组中的元素 binarySearch() 返回值: 如果它包含在数组中,则返回搜 ...
- Java基础知识强化85:System类之arraycopy()方法(数组拷贝)
1. arraycopy方法(数组拷贝) public static void arraycopy(object src,int srcPos,Object dest,int destPos, int ...
- JAVA进阶之旅(二)——认识Class类,反射的概念,Constructor,Field,Method,反射Main方法,数组的反射和实践
JAVA进阶之旅(二)--认识Class类,反射的概念,Constructor,Field,Method,反射Main方法,数组的反射和实践 我们继续聊JAVA,这次比较有意思,那就是反射了 一.认识 ...
随机推荐
- Discrete Logging(poj2417)
Discrete Logging Time Limit: 5000MS Memory Limit: 65536K Total Submissions: 5120 Accepted: 2319 ...
- How Many Sets I(zoj3556)
How Many Sets I Time Limit: 2 Seconds Memory Limit: 65536 KB Give a set S, |S| = n, then how ma ...
- Codeforces1132A——Regular Bracket Sequence(水题)
Regular Bracket Sequence time limit per test:1 second memory limit per test:256 megabytes input:stan ...
- Handing Incomplete Heterogeneous Data using VAEs
目录 概 主要内容 ELBO 网络结构 不同的数据 HI-VAE 代码 Nazabal A., Olmos P., Ghahramani Z. and Valera I. Handing incomp ...
- vue基于Blob.js和 Export2Excel.js做前端导出
1安装三个依赖包 npm install -S file-saver@2.0.2 npm install -S xlsx@0.15.6 npm install -D script-loader@0.7 ...
- Java程序设计基础笔记 • 【目录】
持续更新中- 我的大学笔记>>> 章节 内容 实践练习 Java程序设计基础作业目录(作业笔记) 第1章 Java程序设计基础笔记 • [第1章 初识Java] 第2章 Java程序 ...
- Java面向对象笔记 • 【第1章 面向对象】
全部章节 >>>> 本章目录 1.1 类和对象 1.1.1 类和对象的概念 1.1.2 类的语法结构 1.1.3 对象的创建和使用 1.1.4 对象和引用 1.1.5 实践 ...
- Storm集群使用DRPC功能Version1.0.1
在Storm集群上开启DRPC功能, 基于Storm的1.0.1版本, 并且执行简单的例子测试. 1.DRPC概念 DRPC就是分布式远程过程调用. Storm里面引入DRPC主要是利用storm的实 ...
- 1.HTML基本结构、头部、注释
基本结构 1.HTML基本结构 <html> <head> <meta charset="utf-8"> ...
- js 关于 data.xuNum = xuNum++; 赋值写法 的探讨
1 .源码 let xuNum = 0; let data = []; data.xuNum = xuNum++; console.log(data.xuNum) 2.打印结果 // 0 3.原因 ...