本文详细介绍了Java编程中的方法定义、重载、可变参数、递归以及数组的相关概念和操作，包括数组的声明、初始化、遍历、排序。还展示了如何实现简单的加减乘除计算器及冒泡排序。此外，探讨了稀疏数组的概念和处理方式，以及在特定情况下如何优化存储效率。
Java方法
方法的定义
-
修饰符**(public)** 返回值类型**(int/void)** 方法名**(larger)** （参数类型**(int) 参数名(aaaa）**{
…
方法体
…
return 返回值；
}
-
没有返回值一般返回值类型用void
package com.zengchengjin.method;
public class Demo01 {
public static void main(String[] args) {
int sum = add(1,2);
System.out.println(sum);
}
public static int add(int a,int b){
return a+b;
}
}
package com.zengchengjin.method;
public class Demo02 {
public static void main(String[] args) {
int c = larger(10,10);
System.out.println(c);
}
public static int larger(int a,int b){
int c = 0;
if(a==b){
System.out.println("a==b");
return 0;
}
if(a>b){
c = a;
}else{
c = b;
}
return c;
}
}
方法的重载
- 定义：在一个类中，有相同的函数名称，但形参不同
- 规则
- 方法名称必须相同
- 参数列表必须不同（个数不同或类型不同或参数排列顺序不同等）
- 方法的返回类型可以相同也可以不同
可变参数
-
Java支持传递同类型的可变参数给一个方法；
-
在方法声明中，在指定参数类型后加一个省略号(…)；
如：public static void printMax(double… numbers){ }
-
一个方法中只能指定一个可变参数，而且它必须是方法的最后一个参数，任何普通参数必须在它之前声明。
package com.zengchengjin.method;
public class Demo03 {
public static void main(String[] args) {
Demo03 demo03 = new Demo03();
demo03.test(1,2,4,4,5);
}
public static void test(int... i){
System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
System.out.println(i[4]);
}
}
package com.zengchengjin.method;
public class Demo04 {
public static void main(String[] args) {
printMax(1,2,3,4);
printMax(new double[]{34,21,76});
}
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 number is："+result);
}
}
递归**（能不用就不用，但是要懂递归思想）**
- 递归就是A方法调用A方法，就是自己调用自己；
- 递归结构包括两个部分
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环；
- 递归体：什么时候需要调用自身方法。
package com.zengchengjin.method;
public class Demo05 {
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n){
if(n == 1){
return 1;
}else {
return n*f(n-1);
}
}
}
实现加减乘除计算器
package com.zengchengjin.method;
import java.util.Scanner;
public class Demo06 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("你输入的表达式是：");
double a = scanner.nextDouble();
char way = scanner.next().charAt(0);
double b = scanner.nextDouble();
double sum = 0;
switch (way){
case '+':
sum = plus(a,b);
System.out.println(sum);
break;
case '-':
sum = minus(a,b);
System.out.println(sum);
break;
case '*':
sum = times(a,b);
System.out.println(sum);
break;
case '/':
sum = divide(a,b);
System.out.println(sum);
break;
}
scanner.close();
}
public static double plus(double a,double b){
double sum = a+b;
return sum;
}
public static double minus(double a,double b){
double sum = a-b;
return sum;
}
public static double times(double a,double b){
double sum = a*b;
return sum;
}
public static double divide(double a,double b){
double sum = a/b;
return sum;
}
}
数组（Array）
package com.zengchengjin.array;
public class Demo01 {
public static void main(String[] args) {
int[] nums = new int[10];
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[8] = 9;
nums[7] = 8;
nums[9] = 10;
int sum=0;
for (int i = 0; i < nums.length; i++) {
sum = sum+nums[i];
}
System.out.println(sum);
}
}
package com.zengchengjin.array;
public class Demo02 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
for (int i = 0; i < a.length; i++) {
System.out.print(" "+a[i]);
}
System.out.println();
System.out.println("=============================");
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum +=a[i];
}
System.out.println("它们的和为："+sum);
System.out.println("=============================");
int max = a[0];
for (int i = 0; i < a.length; i++) {
if(a[i] > max)
max = a[i];
}
System.out.println("其中最大的数是："+max);
}
}
package com.zengchengjin.array;
public class Demo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//For-Each循环
for (int array : arrays) {
System.out.print(array+" ");
}
//数组作方法入参
fangfarucan(arrays);
//数组作返回值的输出
int[] reverse = reverse(arrays);
fangfarucan(reverse);
}
public static void fangfarucan(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 = arrays.length-1; i < arrays.length; i++,j--){
result[i] = arrays[j];
}
return result;
}
}
package com.zengchengjin.array;
public class Demo003 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
for(int array : arrays){
System.out.print(array);
}
ffrc(arrays);
int[] reverse = reverse(arrays);
ffrc(reverse);
}
public static void ffrc(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 = arrays.length-1; i < arrays.length; i++,j--) {
result[i] = arrays[j];
}
return result;
}
}
package com.zengchengjin.array;
public class Demo04 {
public static void main(String[] args) {
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
//printArray(array[0]);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
}
}
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+",");
}
}
}
package com.zengchengjin.array;
import java.util.Arrays;
public class Demo05 {
public static void main(String[] args) {
int[] a = {3,6,36,365,34,237,1,87,34};
Arrays.sort(a);//将数组a里的数据按从小到大排序
System.out.println(Arrays.toString(a));
}
}
-
数组的声明和创建
- java语言使用new操作符来创建数组，如：int[] nums = new int[10];
- 数组元素访问从下标0开始
- 获取数组长度：array.length，如：num.length
-
数组的三种初始化
-
静态初始化：int[] a = {1,2,3}；
Man[] mans = {new Man(1,1),new Man(2,2)};
-
动态初始化：int[] a = new int[10];
-
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，它的元素耶被按照实例变量同样的方式被隐式初始化。
-
数组的四个特点：
- 长度确定，一旦被创建，大小不可改变。如果越界，则报错：ArrayIndexOutofBounds（数组下标越界）
- 元素必须是同类型的，不可出现混合类型
- 元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成是对象，数组的每个元素相当于该对象的成员变量，数组本身就是对象，java中的对象是在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
-
-
二维数组和多维数组
- int[] [] a = new int[2] [5]
-
Arrays类
- 数组的工具类java.util.Arrays
- 查看JDK帮助文档
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不必“使用对象来调用
- 具有以下常用功能：
- 给数组赋值：通过fill方法
- 对数组排序：通过sort方法，按升序
- 比较数组：通过equals方法比较数组中元素值是否相等
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作
-
冒泡排序
- 两层循环，外层是冒泡轮数，里层是依次比较，江湖中人尽皆知
- 时间复杂度为n的二次方
package com.zengchengjin.array;
import java.util.Arrays;
public class Demo06 {
public static void main(String[] args) {
int[] array = {223,34,32,4,235,31,87,2,35};
sort(array);
System.out.println(Arrays.toString(array));
}
public static int[] sort(int[] array){
int a =0;
for (int i = 0; i < array.length-1; i++) {
boolean b = false;
for (int j = 0; j < array.length-1; j++) {
if(array[j] > array[j+1]){
a = array[j];
array[j] = array[j+1];
array[j+1] = a;
b = true;
}
}
if(b == false ) {
break;
}
}
return array;
}
}
- 稀疏数组
- 当一个数组中大部分元素是0，或者为同一值时，用来保存数组
- 处理方式
- 记录数组有几行几列，有多少个不同的值
- 把具有不同值的元素及其行列记录在一个小规模的数组中，从而缩小程序的规模
package com.zengchengjin.array;
public class Demo07 {
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
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 < array1.length; i++) {
for (int j = 0; j < array1[i].length; 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];
}
}
}
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("=======================");
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++) {
for (int j = 0; j < array2[i].length-2; j++) {
array3[array2[i][j]][array2[i][j+1]] = array2[i][j+2];
}
}
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
扫一扫
3365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
