本文介绍Java中方法的概念、定义与使用，包括方法的重载、参数传递及返回值处理。此外，阐述了一维数组与二维数组的声明、初始化、遍历与基本操作，如查找与排序。并通过实例演示了数组在实际编程中的应用。
------ android培训、java培训、期待与您交流！ ----------
一、方法
1、方法概述
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。
上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。
2、方法定义及格式
简单的说：方法就是完成特定功能的代码块，在很多语言里面都有函数的定义，函数在Java中被称为方法，翻译为method。
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，…) {
函数体;
return 返回值;
}
3、方法格式解释
①修饰符：比较多，后面会详细介绍。目前先记住public static；
②返回值：类型 用于限定返回值的数据类型；
③方法名：一个名称，为了方便我们调用方法；
④参数类型：限定调用方法时传入参数的数据类型；
⑤参数名：是一个变量，接收调用方法时传入的参数；
⑥方法体：完成功能的代码；
⑦return：结束方法以及返回方法指定类型的值 ；
⑧返回值：程序被return带回的结果，返回给调用者。
4、方法书写事项
如何写一个方法呢?两个明确，①返回值类型：明确功能结果的数据类型；②参数列表：明确有几个参数，以及参数的类型。
注意事项：①方法不调用不执行；②方法与方法是平级关系，不能嵌套定义；③方法定义的时候参数之间用逗号隔开；④方法调用的时候不用在传递数据类型；
④如果方法有明确的返回值，一定要有return带回一个值，没有明确返回值用void声明。
5、方法重载
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
特点：①与返回值类型无关，只看方法名和参数列表；②在调用时，虚拟机通过参数列表的不同来区分同名方法。
<span style="font-size:18px;">class Function {
/**
* java程序运行入口
* jvm自动加载main方法
*/
public static void main(String[] args) {
/*System.out.println(3.0 + 4);
System.out.println(3.0 - 4);
System.out.println(3.0 * 4);
System.out.println(3.0 / 4);
System.out.println(30.0 + 40);
System.out.println(30.0 - 40);
System.out.println(30.0 * 40);
System.out.println(30.0 / 40);
System.out.println(300.0 + 400);
System.out.println(300.0 - 400);
System.out.println(300.0 * 400);
System.out.println(300.0 / 400);*/
// 鉴于以上的代码用常量计算带死板，所以用变量来进行计算
/*double x = jianpan.nextDouble();
double y = jianpan.nextDouble();
System.out.println(x + y);
System.out.println(x - y);
System.out.println(x * y);
System.out.println(x / y);
double a = jianpan.nextDouble();
double b = jianpan.nextDouble();
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);*/
// 针对重复的操作Java语言中可以将重复的代码块（一行或多行）抽取成一个方法，后续只需要调用就可以了
// 这样的好处是，代码量减少了，出错率也减少了，使用起来更加灵活
// 定义一个方法，来实现四则运算
// 如果只是单独的调用没有太大意义
// sum(5, 6);
// 可以直接输出查看结果，但是不一定要查看结果我还可以进行二次计算
// System.out.println(sum(5, 6));
// 建议使用一个变量来接收方法返回的结果值
double result = sum(5, 6);
System.out.println(result + 7);
}
/**
* 这是我们自定义的方法，由需求而定
* 需求：进行两个数字的四则运算
*/
public static double sum(double num1, double num2) {
double he = num1 + num2;
return he;
}
}
</span>
二、数组概要
1. 数组引入
需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。
为了解决这种问题，Java就提供了数组供我们使用。
2、数组特点
①数组是一组数据的集合；
② 数组作为一种引用类型；
③数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型
④数组作为对象，数组中的元素作为对象的属性，除此之外数组还包括一个成员属性length，length 表示数组的长度；
⑤数组的长度在数组对象创建后就确定了，就无法再修改了；
⑥数组元素是有下标的，下标从0 开始，也就是第一个元素的下标为0，依次类推最后一个元素的下标为n-1，我们可以通过数组的下标来访问数组的元素。
3、数组的初始化方式
Java中的数组必须先初始化,然后才能使用。所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
①动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
②静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
三、一维数组的声明和使用
1、数组的声明
一维数组的声明格式有以下两种
①数组元素的类型[] 变量名称
②数组元素的类型变量名称[]
数组元素的类型，可以是java 中的任意类型，变量名称可以是任意合法的标识符，上面两种格式较常用的是第一种，例如：int [] a;Student[] stu，在一行中也可以声明多个数组，例如：int[] a, b, c
2、数组的创建
数组有两种创建方式，第一种：使用new 操作符来创建数组，格式为：new 数组元素的数据类型[数组元素的个数]
①基本类型的数组
<span style="font-size:18px;">public class ArrayTest01 {
public static void main(String[] args) {
// 声明int 类型的数组，长度为5
// 数组中的元素必须为int 类型
int[] data = new int[5];
// 对数组中的元素进行赋值，如果不赋值默认为该类型的默认值，以上数组默认为0。
// 如何赋值？变量名[下标],下标从0 开始
data[0] = 1;
data[1] = 2;
data[2] = 3;
data[3] = 4;
data[4] = 5;
// 输出数组中的元素，变量名[下标]
System.out.println(data[0]);
System.out.println(data[1]);
System.out.println(data[2]);
System.out.println(data[3]);
System.out.println(data[4]);
System.out.println("-----------------------");
// 采用length 属性可以取得数组的长度
for (int i = 0; i < data.length; i++) {
System.out.println(data[i]);
}
// 输出指定的数组元素
System.out.println("data[3]=" + data[3]);
// 会抛出ArrayIndexOutOfBoundsException 异常
// 数组下标越界
System.out.println("data[10]=" + data[10]);
// 不能成功赋值，数组中的类型必须是一种类型
// data[0] = "iiii";
}
}</span>②引用类型的数组
<span style="font-size:18px;">public class ArrayTest02 {
public static void main(String[] args) {
// 声明引用类型的数组
Student[] student = new Student[2];
// 出现空指针
// 因为引用类型的数组，它采用null 作为默认的初始化值
student[0].id = 1001;
student[0].name = "张三";
student[1].id = 1002;
student[1].name = "李四";
}
}
class Student {
int id;
String name;
}</span><span style="font-size:18px;">public class ArrayTest03 {
public static void main(String[] args) {
// 声明引用类型的数组
Student[] student = new Student[2];
// 初始数组元素为Student 对象
/*
* student[0] = new Student(); student[0].id = 1001; student[0].name =
* "张三"; student[1] = new Student(); student[1].id = 1002;
* student[1].name = "李四";
*/
// 可以采用如下方式赋值
Student zhangsan = new Student();
zhangsan.id = 1001;
zhangsan.name = "张三";
student[0] = zhangsan;
Student lisi = new Student();
lisi.id = 1002;
lisi.name = "李四";
student[1] = lisi;
for (int i = 0; i < student.length; i++) {
System.out.println("id=" + student[i].id + ", name="
+ student[i].name);
}
}
}
class Student {
int id;
String name;
}</span>第二种，使用数组的初始化语句，格式为：数组元素的类型[] 变量名称= {数组元素1，数组元素2,......数组元素n}或数组元素的类型变量名称[] = {数组元素1，数组元素2,......数组元素n}
<span style="font-size:18px;">public class ArrayTest04 {
public static void main(String[] args) {
// 静态初始化
int[] data = { 1, 2, 3, 4, 5 };
for (int i = 0; i < data.length; i++) {
System.out.println(data[i]);
}
Student zhangsan = new Student();
zhangsan.id = 1001;
zhangsan.name = "张三";
Student lisi = new Student();
lisi.id = 1002;
lisi.name = "李四";
// 静态初始化
Student[] students = { zhangsan, lisi };
for (int i = 0; i < students.length; i++) {
System.out.println("id=" + students[i].id + ", name="
+ students[i].name);
}
}
}
class Student {
int id;
String name;
}</span><span style="font-size:18px;">class ArrayTest2 {
/**
* java程序运行入口
* jvm自动加载main方法
*/
public static void main(String[] args) {
System.out.println("******欢迎使用传智播客包子点餐系统******");
Scanner input = new Scanner(System.in);
String[] foods = new String[5];
// 请录入食物数据
System.out.println("请录入食物数据");
/*foods[0] = input.nextLine();
foods[1] = input.nextLine();
foods[2] = input.nextLine();
foods[3] = input.nextLine();
foods[4] = input.nextLine();
System.out.println("您录入了5条数据，最后一条数据是：" + foods[4]);*/
for (int i = 0; i < foods.length; i++) {
foods[i] = input.nextLine();
}
for (int i = 0; i < foods.length; i++) {
System.out.println(foods[i]);
}
}
}</span>四、二维数组的声明和使用
1、概述
我们传智播客的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。由此可见：其实二维数组其实就是一个元素为一维数组的数组。
2、定义格式
①格式1：
数据类型[][] 变量名 = new 数据类型[m][n];m表示这个二维数组有多少个一维数组，n表示每一个一维数组的元素个数。
举例：int[][] arr = new int[3][2];定义了一个二维数组arr，二维数组中有3个一维数组，名称是arr[0],arr[1],arr[2]，每个一维数组有2个元素，可以通过arr[m][n]来获取，表示获取第m+1个一维数组的第n+1个元素。
②格式2
数据类型[][] 变量名 = new 数据类型[m][];m表示这个二维数组有多少个一维数组，这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：int[][] arr = new int[3][];arr[0] = new int[2];
arr[1] = new int[3];arr[2] = new int[1];
③格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
举例：int[][] arr = {{1,2,3},{4,6},{6}};
<span style="font-size:18px;">class Array2Demo {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//输出二维数组名
System.out.println(arr);//
//输出一维数组名
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
}
}</span>3、二维数组遍历
<span style="font-size:18px;">class Array2Test{
public static void main(String[] args) {
//二维数组静态初始化
int[][] arr = {{3,4,6},{1},{8,5,7,4}};
//遍历每一个一维数组,
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[0][2]);
System.out.println(arr[1][0]);
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);
System.out.println(arr[2][3]);
System.out.println("-------------------------------------------------");
//改进版遍历
printArr(arr[0]);
printArr(arr[1]);
printArr(arr[2]);
System.out.println("----------------用for循环嵌套去实现遍历二维数组-------------");
//[3,4,6,1,8,5,7,4]
//遍历出来每个二维数组元素 一维数组中 数组名.length表示的是数组中元素的个数
//二维数组中 二维数组名.length ,表示二维数组中一维数组的个数
//arr[0] 第一个一维数组 arr[1]第二个一维数组
//System.out.println(arr.length);
System.out.print("[");
//我想拿到每一个一维数组
for(int i = 0; i<=arr.length-1;i++){
//arr[i] 第i+1个一维数组 arr[i][0]
for(int j =0;j<=arr[i].length-1;j++ ){
//arr[i][j] 第i+1个一维数组中第j+1个元素
if( i==arr.length-1 && j==arr[i].length-1){
System.out.print(arr[i][j]);
}else{
System.out.print(arr[i][j]+",");
}
}
}
System.out.println("]");
}
//写一个一维数组遍历的方法 要输出的效果是[1,2,3]
public static void printArr(int[] arr){
System.out.print("[");
for(int i = 0;i<=arr.length-1;i++){
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
}
System.out.println("]");
}
}</span><span style="font-size:18px;">/*
A:案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44 {22,66,44}
第二季度：77,33,88 {77,33,88}
第三季度：25,45,65 {25,45,65}
第四季度：11,66,99 {11,66,99}
分析: 应该定义一个求和变量.
用二维数组来包装一下我的销售额
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}}
//求和
是不是要求每个月的销售额相加之和
是不是要把每个月的销售额拿出来 做累加
*/
class Array2Test2{
public static void main(String[] args) {
//将公司的销售额用二维数组来包装一下
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
//定义累加变量
int sum = 0;
for(int i = 0;i<=arr.length-1;i++){
//arr[i] --每个一维数组 每个季度的销售额
for(int j = 0;j<=arr[i].length-1;j++){
//arr[i][j] ---每个月的销售额
sum += arr[i][j];
}
}
System.out.println("这个公司的年销售额为:"+sum+"万元");
}
}
</span>练习题：定义数组存储三名同学姓名、年龄、成绩信息，并查找出分数最高的同学信息。
<span style="font-size:18px;">import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
//定义一个Student数组
//格式：数据类型[] 数组名 = new 数据类型[长度];
//格式：数据类型[] 数组名 = new 数据类型[]{值1，值2，....，值n};
//格式：数据类型[] 数组名 = {值1，值2，....，值n};
Scanner sc = new Scanner(System.in);
System.out.println("请输入学员数量：");
int count = sc.nextInt();
Student[] stuArray = new Student[count];
for(int i = 0;i < stuArray.length ; i++){
System.out.println("请输入第：" + (i + 1) + " 名学员信息：");
System.out.println("姓名：");
String name = sc.next();
System.out.println("年龄：");
int age = sc.nextInt();
System.out.println("分数：");
int score = sc.nextInt();
//实例化一个Student对象
Student stu = new Student(name,age,score);
//将对象添加到数组
stuArray[i] = stu;
}
//遍历数组
for(int i = 0;i < stuArray.length ; i++){
Student stu = stuArray[i];
System.out.println(stu.name + "," + stu.age + "," + stu.score);
}
//找出分数最高的学员
Student maxStudent = getMaxStudent(stuArray);
System.out.println("最高分：" + maxStudent.score + " 姓名：" + maxStudent.name + ",年龄：" + maxStudent.age);
//找出最低分学员
//又想再存储1名学员信息
}
//定义一个方法，可以找出最高分学员
//1.方法做什么事情：找出Student数组中的成绩最高的Student引用
//2.是否需要外部数据：决定"形参"；
//3.方法做完事后，是否需要告诉调用者一个结果：决定"返回值"
public static Student getMaxStudent(Student[] stuArr){
//假设第一个学员是最高分
Student maxStudent = stuArr[0];
//遍历
for(int i = 0; i < stuArr.length ; i++){
if(stuArr[i].score > maxStudent.score){
maxStudent = stuArr[i];
}
}
return maxStudent;
}
}
public class Student {
String name;
int age;
int score;
public Student(){
}
public Student(String name,int age,int score){
this.name = name;
this.age = age;
this.score = score;
}
}
</span>
五、数组的排序
1、选择排序
<span style="font-size:18px;">public class ArraysDemo {
public static void main(String[] args) {
int[] arr ={24,69,80,57,13};
printArr(arr);
//做一个选择排序的方法
searchSort(arr);
printArr(arr);
}
//选择排序:
public static void searchSort(int[] arr) {
//写一个循环 外层循环控制循环次数
for (int i = 0; i < arr.length-1; i++) {
//内层循环控制参与比较的元素
for (int j = i+1; j < arr.length; j++) {
if (arr[i]>arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
//数组遍历方式
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}</span>
2、冒泡排序
<span style="font-size:18px;">public class ArraysDemo {
public static void main(String[] args) {
int[] arr ={24,69,80,57,13};
printArr(arr);
//做一个冒泡排序
//bubbleSort(arr);
//做一个选择排序的方法
searchSort(arr);
printArr(arr);
}
//冒泡排序
public static void bubbleSort(int[] arr) {
//外循环控制循环次数
for (int i = 0; i < arr.length-1; i++) {
//i 0 1 2 3
//内层循环控制参与比较的元素
//j < arr.length-1-i 每次比较的次数
//防止了重复比较
for (int j = 0; j < arr.length-1-i; j++) {
//arr[j] arr[j+1]
if(arr[j]>arr[j+1]){
//两个元素交换 第三方变量
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}</span>3、快速排序
快速排序(QuickSorting)是对冒泡排序的一种改进，由C.A.R.Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
<span style="font-size:18px;">//快速排序法[Demo135.java]
public class Demo135{
public static void main(String []args){
int arr[]={-1,-5,6,2,0,9,-3,-8,12,7};
QuickSort qs=new QuickSort();
qs.sort(0, arr.length-1, arr);
//输出最后结果
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
class QuickSort{
public void sort(int left,int right,int [] arr){
int l=left;
int r=right;
int pivot=arr[(left+right)/2];//找中间值
int temp=0;
while(l<r){
while(arr[l]<pivot) l++;
while(arr[r]>pivot) r--;
if(l>=r) break;
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
if(arr[l]==pivot) --r;
if(arr[r]==pivot) ++l;
}
if(l==r){
l++;
r--;
}
if(left<r) sort(left,r,arr);
if(right>l) sort(l,right,arr);
}
}
</span>六、数组的查找
在java中，常用的查找方式有两种：①顺序查找(最简单，效率最低)；②二分查找。
<span style="font-size:18px;">public class ArraysDemo2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//查找6 的位置
// int index = searchIndex(arr,6);
// System.out.println(index);
//二分查找
// int index = halfSearch(arr,10);
//
// System.out.println(index);
//
// System.out.println(halfSearch(arr,100));
//你要查找的数组必须是有序的,升序
int[] arr1 = {11,23,34,46,58,69,79,82,93,1044};
System.out.println(halfSearch(arr1,82));
}
//二分查找
public static int halfSearch(int[] arr, int key) {
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
//int mid = (min+max) >>> 1;
while(arr[mid]!=key){
if (key>arr[mid]) {
//更新最小的索引
min = mid +1;
} else {
//更新最大索引
max = mid-1;
}
if(min>max){
return -1;
}
mid = (min+max)/2;
}
return mid;
}
public static int searchIndex(int[] arr, int key) {
int index = -1;
for(int i = 0;i<arr.length;i++){
if(arr[i]==key){
index = i;
return index;
}
}
return index;
}
}</span>七、Arrays工具类
<span style="font-size:18px;">import java.util.Arrays;
/*
* A:Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。
B:成员方法
public static int binarySearch(int[] a,int key)
二分查找
public static void sort(int[] a)
性能调优的快速排序
升序
public static String toString(int[] a)
任意类型数组都可以按照字符串显示
*/
public class ArraysDemo3 {
public static void main(String[] args) {
//int[] arr = {10,20,30,40,50,60,70,80,90,100};
//int index = Arrays.binarySearch(arr, 0);
//System.out.println(index);
// System.out.println(Arrays.binarySearch(arr, 15));
// System.out.println(Arrays.binarySearch(arr, 99));
// public static void sort(int[] a)
// int[] arr1 = {23,57,23,45,621,5,7,1,71,5};
int[] arr =null;
String s = Arrays.toString(arr);
System.out.println(s);
// System.out.println(s);
// //排序
// Arrays.sort(arr1);
// //在输出
// System.out.println(Arrays.toString(arr1));
}
}</span>
扫一扫
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
