Java方法及数组相关原理解析

Java方法及数组相关原理解析

方法

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计的方法，最好保持方法的原子性，就是一个方法只完成1个功能，有利于后期的扩展。

方法重载

重载就是在一个类中，有相同的函数名称，但参数不同的函数

重载规则：

方法名称必须相同

参数列表必须不同（个数不同、类型不同、参数排序顺序不同）

方法返回值类型可相同也可不相同

仅仅返回类型不同不足以成为方法的重载

实现原理：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

public static void main(String[] args) {

for (int i=0;i

System.out.println("args["+i+"]:"+args[i]);

}

}//传递命令行参数给main函数

要在 cmd 界面下才能运行！！！

可变参数

JDK 1.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方法！自己调用自己！

递归结构包括两个部分:

递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。

递归体:什么时候需要调用自身方法

public static int f(int n){

if(n==1){

return 1;

}else {

return n*f(n-1);

}

}

数组

数组是相同类型数据的有序集合.

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的声明

int[] nums=new int[5];

nums[0]=1;nums[1]=2;nums[2]=3;nums[3]=4;nums[4]=5;

数组的三种初始化

//1静态初始化

int[] a={1,2,3,4,5,6,7,8};

System.out.println(a[0]);

//2动态初始化 ：包含3默认初始化

int[] b=new int[10];

b[0]=10;

b[1]=10;

System.out.println(b[0]);

System.out.println(b[1]);

System.out.println(b[2]);//默认初始化，输出结果为0

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界

数组的应用

//反转数组

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

for (int i = 0,j=result.length-1; i

result[j]=arrays[i];

}

return result;

}

多维数组

int a[][]=new int[2][5];//以上二维数组可以看成一个两行五列的数组

Array类

查看 JDK 帮组文档！！！

常用功能：

给数组赋值：fill

给数组排序：sort

比较数组：equals 比较数组中元素值是否相等

查找数组元素：binarySearch 方法能对排序好的数组进行二分查找法操作

冒泡排序

public static int[] sort(int[] array){

// 冒泡排序

int temp=0;

for (int i = 0; i < array.length-1; i++) {

for (int j = 0; j < array.length-1-i; j++) {//i表示已经排好的数字个数，所以在内层循环时减去i，减少比较次数

if(array[j+1]

temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

return array;

}

稀疏数组

稀疏数组的处理方式是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//看代码才能看懂

public static void main(String[] args) {

//稀疏数组

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();

}

System.out.println("================");

//转换为稀疏数组

//获取数组中有效值

int sum= 0;

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if(array1[i][j]!=0){

sum++;

}

}

}

System.out.println("有效值个数："+sum);

//创建稀疏数组

int[][] array2=new int[sum+1][3];

array2[0][0]=11;

array2[0][1]=11;

array2[0][2]=sum;

//遍历二维数组，将有效值存在稀疏数组中

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("稀疏数组");

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];

}

//打印输出

System.out.println("输出还原数组：");

for (int[] ints:array3) {

for(int anint:ints){

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

//输出还原数组

}

System.out.println();

}

}

System.out.println("args["+i+"]:"+args[i]);

}

}//传递命令行参数给main函数

要在 cmd 界面下才能运行！！！

可变参数

JDK 1.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方法！自己调用自己！

递归结构包括两个部分:

递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。

递归体:什么时候需要调用自身方法

public static int f(int n){

if(n==1){

return 1;

}else {

return n*f(n-1);

}

}

数组

数组是相同类型数据的有序集合.

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的声明

int[] nums=new int[5];

nums[0]=1;nums[1]=2;nums[2]=3;nums[3]=4;nums[4]=5;

数组的三种初始化

//1静态初始化

int[] a={1,2,3,4,5,6,7,8};

System.out.println(a[0]);

//2动态初始化 ：包含3默认初始化

int[] b=new int[10];

b[0]=10;

b[1]=10;

System.out.println(b[0]);

System.out.println(b[1]);

System.out.println(b[2]);//默认初始化，输出结果为0

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界

数组的应用

//反转数组

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

for (int i = 0,j=result.length-1; i

result[j]=arrays[i];

}

return result;

}

多维数组

int a[][]=new int[2][5];//以上二维数组可以看成一个两行五列的数组

Array类

查看 JDK 帮组文档！！！

常用功能：

给数组赋值：fill

给数组排序：sort

比较数组：equals 比较数组中元素值是否相等

查找数组元素：binarySearch 方法能对排序好的数组进行二分查找法操作

冒泡排序

public static int[] sort(int[] array){

// 冒泡排序

int temp=0;

for (int i = 0; i < array.length-1; i++) {

for (int j = 0; j < array.length-1-i; j++) {//i表示已经排好的数字个数，所以在内层循环时减去i，减少比较次数

if(array[j+1]

temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

return array;

}

稀疏数组

稀疏数组的处理方式是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//看代码才能看懂

public static void main(String[] args) {

//稀疏数组

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();

}

System.out.println("================");

//转换为稀疏数组

//获取数组中有效值

int sum= 0;

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if(array1[i][j]!=0){

sum++;

}

}

}

System.out.println("有效值个数："+sum);

//创建稀疏数组

int[][] array2=new int[sum+1][3];

array2[0][0]=11;

array2[0][1]=11;

array2[0][2]=sum;

//遍历二维数组，将有效值存在稀疏数组中

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("稀疏数组");

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];

}

//打印输出

System.out.println("输出还原数组：");

for (int[] ints:array3) {

for(int anint:ints){

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

//输出还原数组

}

System.out.println();

}

}

result[j]=arrays[i];

}

return result;

}

多维数组

int a[][]=new int[2][5];//以上二维数组可以看成一个两行五列的数组

Array类

查看 JDK 帮组文档！！！

常用功能：

给数组赋值：fill

给数组排序：sort

比较数组：equals 比较数组中元素值是否相等

查找数组元素：binarySearch 方法能对排序好的数组进行二分查找法操作

冒泡排序

public static int[] sort(int[] array){

// 冒泡排序

int temp=0;

for (int i = 0; i < array.length-1; i++) {

for (int j = 0; j < array.length-1-i; j++) {//i表示已经排好的数字个数，所以在内层循环时减去i，减少比较次数

if(array[j+1]

temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

return array;

}

稀疏数组

稀疏数组的处理方式是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//看代码才能看懂

public static void main(String[] args) {

//稀疏数组

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();

}

System.out.println("================");

//转换为稀疏数组

//获取数组中有效值

int sum= 0;

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if(array1[i][j]!=0){

sum++;

}

}

}

System.out.println("有效值个数："+sum);

//创建稀疏数组

int[][] array2=new int[sum+1][3];

array2[0][0]=11;

array2[0][1]=11;

array2[0][2]=sum;

//遍历二维数组，将有效值存在稀疏数组中

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("稀疏数组");

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];

}

//打印输出

System.out.println("输出还原数组：");

for (int[] ints:array3) {

for(int anint:ints){

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

//输出还原数组

}

System.out.println();

}

}

temp=array[j];

array[j]=array[j+1];

array[j+1]=temp;

}

}

}

return array;

}

稀疏数组

稀疏数组的处理方式是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

//看代码才能看懂

public static void main(String[] args) {

//稀疏数组

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();

}

System.out.println("================");

//转换为稀疏数组

//获取数组中有效值

int sum= 0;

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if(array1[i][j]!=0){

sum++;

}

}

}

System.out.println("有效值个数："+sum);

//创建稀疏数组

int[][] array2=new int[sum+1][3];

array2[0][0]=11;

array2[0][1]=11;

array2[0][2]=sum;

//遍历二维数组，将有效值存在稀疏数组中

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("稀疏数组");

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];

}

//打印输出

System.out.println("输出还原数组：");

for (int[] ints:array3) {

for(int anint:ints){

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

//输出还原数组

}

System.out.println();

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。