今日内容
-
数组
-
方法
数组的反转：数组中的元素颠倒顺序，如数组1，2，3，4，5，数组反转后变成5，4，3，2，1.
思路：本质是交换两个变量的值。两种方式
- 实现反转，就需要将数组的最远端和最近端元素互换。
- 定义两个变量，保存数组的最小索引和数组的最大索引。
- 让两个索引上的元素交换位置
- 最小的索引变量++，最大的索引变量–，再次交换位置
- 最小的索引超过了最大索引，数组反转结束
【需要借助第三方变量】
准备一个需要反转的数组 int[] arr = {1,2,3,4,5,6};
定义两个索引变量，一个索引变量指向最小索引，一个索引变量指向最大索引
int min = 0;
int max = arr.length-1;
遍历数组，让两个索引变量产生变化
min++;
max--;
条件 min < max
交换最小索引元素和最大索引元素,需要定义第三方变量
int temp = 0;
temp = arr[min];//把最小的索引元素赋值给第三方变量temp
arr[min] = arr[max];//把最大的索引元素赋值给最小索引的元素
arr[max] = temp;//把第三方变量的值赋值给最大索引的元素
public static void main(String[] args){
int[] arr = {1,2,3,4,5};
//遍历数组 for 循环次数已知
//for(1;2;4){3} 初始化语句一般要放在循环内，逗号隔开多个语句，循环结束循环内定义的变量直接释放
//方法一 定义三个变量
//定义最小索引为min，最大索引为max，交换时需要借助第三变量
for(int min = 0,int max = arr.length-1; min < max; min++, max--){
int temp = arr[min]; //变量初始化
arr[min] = arr[max];
arr[max] = temp;
}
//查看反转之后的数组内容
for(int i = 0; i <= arr.length-1; i++){
System.out.println(arr[i]);
}
//方法二 定义两个变量
//定义一个最小的索引变量 i最大的索引值为arr.length-1-i.交换时需要借助第三变量
//当i=0时，最小索引0，最大索引arr.length-1-0;
//当i=1时，最小索引1，最大索引arr.length-1-1;
//结束交换--->
for(int i = 0; i < arr.length/2; i++){
int temp = 0;//一定要设置初始值（初始化），变量初始化以后才能使用
temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
for(int i = 0; i <arr.length; i++){
System.out.println(arr[i]);//2
}
}
二维数组
定义方式：和一维数组是一样的，也有三种方式
方式一：
数组的数据类型[][] 数组名称 = new 数组的数据类型[长度1][长度2];
长度1 不可省略，代表该二维数组里面存储的元素个数
长度2 可省略，代表该二维数组里面的元素（数组里面的元素个数），而且它里面的数组元素个数一样
如： int[][] arr = new int [3][2];
长度3----该arr数组里面有3个元素（数组）
长度2----该arr数组里面的每个数组元素都有2个元素
相当于--- int[][] arr = {{0,0},{0,0},{0,0}};
方式二：
数组的数据类型[][] 数组名称 = new 数组的数据类型[][]{{元素1，元素2...},{元素1，元素2...},{元素1，元素2...}...{元素1，元素2...}};
方式三：
数组的数据类型[][] 数组名称 = {{元素1，元素2...},{元素1，元素2...},{元素1，元素2...}...{元素1，元素2...}};
二维数组元素访问方式
借助于【索引】
格式：
数组名称[索引]---访问的是二维数组的元素
//访问二维数组当中的一维数组里面的元素
数组名称[一维数组的索引值][一维数组里面的元素索引值]
如 int[][] arr = {{10,20,50},{30,40,80},{15,100}};
//访问arr数组当中的10元素
arr[0][0] = 10;
//访问arr数组的80元素
arr[1][2]
方法
概念：在程序中要去是实现的某一个功能，需要包含多条语句，这些语句包含循环语句结构、选择语句结构等等共同来处理一件事情。
定义方法的格式详解
public static void main(String[] args){
//方法体内容
return
}
方法比喻成工厂
蒙牛工厂
产出物：奶制品
void 空的，无效的，
String[] args 参数--->变量
方法定义的完整格式：修饰符 返回值类型 方法名称（参数类型1 参数名称1，参数类型2 参数名称2。。。）{}
修饰符： public static
返回值类型： void 方法最终产生的数据结果是什么样的
方法名称： main 【不是关键字】方法的名字，名字自定义–标识符，采用小驼峰
参数类型：进入方法当中的数据的类型
参数名称： 进入方法当中的数据对应的变量名称
方法体： 方法需要执行的功能，由若干行代码组成的。
return：【关键字】一般认为有两个作用。第一将后面的返回值返回给程序；第二停止当前正在执行的方法。
返回值： 就是方法执行最终产生的数据结果。
备注：
- return后面的【返回值】，必须和方法声明上的【返回值类型】保持一致。
- 方法不允许嵌套，不允许定义在类的外面
- 方法只能并列，并且必须定义在类的里面 。
//定义两个int数字相加的方法
public class MethodDemo01{
public static void main(String[] args){
//定义两个int数字相加的方法，得到一个结果
//定义一个方法的三要素
/*
返回值类型：int 返回值类型和数据类型是一样的
方法名称：sum
参数列表：int a, int b
*/
//方法定义的完整格式：修饰符 返回值类型 方法名称（参数类型1 参数名称1，参数类型2 参数名称2。。。）{}
//1单独调用
sum(10,20);
System.out.println("========");
//2打印调用
System.out.println(sum(10,20));
System.out.println("========");
//3赋值调用
int number = sum(10,20);
System.out.println("number的值为：" + number);
/*//1单独调用
eatFoof("小刘","小明");
System.out.println("========");
//2打印调用
System.out.println(eatFoof("晓莉","小明"));
System.out.println("========");
//3赋值调用
String number = eatFoof("小明","小红");
System.out.println("number的值为：" + number);
会出错，类型不一致。函数返回类型为void。引用为空？
*/
}
public static int sum(int a, int b){
System.out.println("方法调用1");
int result = a + b;
//此时方法需要有返回值 需要用到返回值语句
//格式：return 具体的返回值；
return result;
}
//定义两个人去吃饭功能
/*
方法定义的三要素：
返回值类型：void
方法名称：eatfood
参数列表： String p1, String p2
*/
public static void eatFoof(String p1, String p2){
System.out.println("今天是一个吃饭的好天气");
}
}
方法调用【重点】
三种调用格式：
-
单独调用：方法名称（参数具体值）；
-
打印调用：System.out.println（方法名称（参数具体值））；
-
赋值调用：数据类型 变量名称 = 方法名称（参数具体值）；
备注：
当返回值类型是void的时候，这种方法只能单独调用，不能进行打印调用或者赋值调用。
返回值类型一般可以理解为数据类型（基本数据类型和引用数据类型），此外还包含一种void类型。当方法执行完毕不需要给程序的调用者返回任何的数据结果时，可以指定该方法的返回值类型为void，此时只能【单独调用】。
1 方法开始调用
2实际参数传递
3方法体内执行
4方法结束返回 ：将返回值返回给程序调用者位置
注意事项：
- 方法定义的先后顺序无所谓
- 方法定义不能嵌套，不能在一个方法内部定义另外一个方法
- 方法定义之后，自己不会执行，如果希望执行，一定要进行方法的调用
方法重载
对于功能类似的方法来说，因为参数列表不一样，却需要定义不同的方法名称，记忆麻烦。
public class MethodDemo03{
public static void main(String [] args){
//计算一个整数和一个小数的和，整数为第一个参数，小数为第二个参数
int num = sum03(10,3.14);
//计算一个整数和一个小数的和，小数为第一个参数，整数为第二个参数
int num = sum03(3.14,10);
}
//计算两个数的和,得到一个整数
//计算两个整数的和
public static int sum01(int a, int b){
return (a+b);
}
//计算两个小数的和
public static int sum02(double a,double b){
return (int)(a+b);
}
//计算一个整数和一个小数的和
public static int sum03(int a, double b){
return (int)(a+b);
}
//计算一个小数和一个整数的和
public static int sum04(double a, int b){
return (int)(a+b);
}
public static int sum04(double d, int e){
return (int)(d+e);//与上面方法一样，报错
}
}
如果在类中定义方法时，方法的参数列表不一样，虽然方法名称一样，但是程序会认为这是一个新方法。
方法重载（overload）：在一个类中，多个方法名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称即可，就可以实现类似的多个功能
方法的重载与哪些因素有关：
- 参数个数不同
- 参数类型不同
- 参数多类型顺序不同
方法重载与哪些因素无关：
- 与参数的名称无关
- 与方法的返回值类型无关
- 与方法的修饰符无关
练习：在调用输出语句时，不管传入什么类型的数据，都把该数据打印在控制台中
模拟输出语句中的println方法效果，传递什么类型的数据，就输出什么类型的数据，只允许定义一个方法println
public static void main(String[] args){
public static int println
}
public void println(int a){
System.out.println(a)
}
public void println(char a){
System.out.println(a)
}
public void println(String a){
System.out.println(a)
}
public void println(double a){
System.out.println(a)
}
public void println(byte a){
System.out.println(a)
}
public void println(long a){
System.out.println(a)
}
public void println(boolean a){
System.out.println(a)
}
public void println(float a){
System.out.println(a)
}
//判断以下哪些方法时重载关系
public static void add(){}//正确重载
public static void add(int a){}//正确重载
static void add(int a,int b){}//代码错误：与第8行冲突
public static void add(double a,int b){}//正确重载
public static void add(int b,double a){}//代码错误：和第6行冲突
static void add(int a, double b){}//代码错误：和第5行冲突
public static void Add(){}//代码正确不会报错，但是不是有效重载
public static void add(int i,int j){}//代码错误：和第3行冲突
数组作为方法参数和返回值
数组作为方法参数
数组作为应用类型能够当成方法的参数进行传递
数组作为方法参数传递，传递的参数是数组内存的地址
public static void main(String[] args){
int[] arr = {1,2,3,4,5};
//调用方法，传递数组，输出数组内存地址
println(arr);
}
/*
创建方法，方法接收数组类型的参数
进行数组的遍历
*/
public static void println(int[] arr){
//数组遍历
for(int i = 0; i <= arr.length-1;i++){
System.out.println(arr[i]);
}
}
数组作为方法的返回值
- 数组作为方法的返回值，返回的是数组的内存地址。
public static void main(String[] args){
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
System.out.println(arr);//此时是一个内存地址哈希值
}
/*
创建方法，返回值是数组类型
return 返回数组的内存地址
*/
public static int[] getArray(){
int[] arr = {1,3,5,9,11};
//此时返回数组的内存地址，返回给调用者
return arr;
}
一个方法可以有0，1，多个参数；但是只能有0个或者1个返回值，不能有多个返回值。如果我们希望一个方法当中产生了多个结果数据，这些多个结果数据同时需要返回，解决方案：使用一个容器（数组），作为方法的返回值类型即可。
public static void main(String[] args){
int a = 10;
int b = 20;
change(a,b);
System.out.println(a);//a=10
System.out.println(b);//b=20
}
public static void change(int a, int b){//变量的定义域，两个a b不同/没有return
a = a + b;//30
b = b + a;//50
}
public static void main(){
int[] arr ={10,20};
changeArray(arr);
System.out.println(arr[0]);//arr[0]=30
System.out.println(arr[1]);//arr[1]=50
}
public static void changeArray(int[] arr){//引用传递，传递地址
arr[0]=30;
arr[1]=50;
}
作业
int[][] arr={{10,20,50},{30,40,80},{15,100}};
//排序之后的数组内容：
{{10,15,20},{30,40,50},{80,100}};
//二维数组累加求和
int[][] arr={{10,20,50},{30,40,80},{15,100}};
package order;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;
/*
二维数组排序
思路：1.二维转一维：二维数组行数、二维数组列数、二维数组的元素个数 使用循环遍历两成for循环
2.一维排序：使用排序方法（冒泡）两层for循环。
3.打印排序好的二维数组：循环遍历打印，注意变成二位数组。
*
*/
public class TwoArray {
public static void main(String[] args) {
int[][] arr = {{5,4,1},{2,7},{3,6,8},{3,6}};
int count = 0;
int count1 = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
count++;//计算出二维数组arr的总共个数
}
count1++;//计算出二维数组的一维数组个数
}
System.out.println(count);
System.out.println(count1);
System.out.println("===============");
int sum = 0;
int[] arr1 = new int[count];
int count3 = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr1[count3]= arr[i][j];
System.out.print(arr1[count3]);
count3++;//将二维数组arr赋值给一维数组arr1
sum += arr[i][j];
}
System.out.println();
}
System.out.println("总数是" + sum);
System.out.println("==========");
for (int i = 0; i < count; i++) {
for (int j = i; j < count; j++) {
if(arr1[i]>arr1[j]){//一维数组ar1升序排序
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
}
}
int count4 = 0;
for (int i = 0; i < count1; i++) {
for (int k = 0; k < arr[i].length; k++) {
arr[i][k] = arr1[count4];
System.out.print(arr[i][k]);
count4++;
}
System.out.println();
}
}
}
扫一扫
960
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
