文章详细介绍了Java中一维数组和二维数组的声明、创建、初始化、引用以及操作，包括作为函数参数和返回值。还涵盖了增强型for循环、冒泡排序和方法的使用，如无参无返回值、有参有返回值的方法，以及方法重载和传值的概念。
目录
Java一维数组
数组：相同类型的数据按顺序组成的引用数据类型
数组申明
1.数据类型[] 数组名; int[] arr;
2.数据类型 数组名[]; int arr[];
数组创建
1.先申明后创建
//数据类型[] 数组名;
//数组名 = new 数据类型[数组长度];
int[] arr;
arr = new int[10];2.申明的同时创建
// 数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[10];数组初始化
int[] arr = {1,2,3,4,5};
数组长度：arr.length
数组元素引用
数组名[下标]
例子
public static void main(String[] args) {
//申明一个整型数组
int[] intArray;
//声明一个字符串类型数组
String strArray[];
//创建一个数组
intArray=new int[5];
strArray=new String[10];
//声明数组的同时进行创建
float[] floatArray=new float[4];
//初始化数组
char[] ch={'a','b','c','d'};
System.out.println("ch的长度为："+ch.length);
System.out.println("intArray数组的第二个元素为："+intArray[1]);
System.out.println("strArray第五个元素为："+strArray[4]);
System.out.println("floatAraay第三个元素为n:"+floatArray[2]);
//循环为整形数组赋值
for(int i=0;i<5;i++) {
intArray[i]=i;
}
for(int i=0;i<5;i++) {
System.out.println("整型数组："+intArray[i]);
}
}
}数组作为函数参数
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}数组作为函数返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}增强型for循环
格式
for(声明语句 : 表达式) {
//代码句子
}声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法
例子
int[] arr={1,2,3,4,5};
for(int n:arr){
System.out.println(n);
}与普通for循环的区别
1、增强型for循环遍历数组时不需要下标，主要用于数组或者集合的遍历，遍历完毕时循环会结束执行。
2、普通for循环需要三个条件，包括循环变量、循环结束条件和循环变量的变化。在需要使用下标的数组遍历时，可以使用普通for循环。比如：从键盘接收数组元素时，提示输入第几个元素。
冒泡排序
public class SortDemo{
public static void main(String[] args) {
// 冒泡排序
int[] a= {22,11,33,55,44,66,};
System.out.println("排序前的数组元素为：");
for(int n:a) System.out.print(n+" ");
int temp;
for(int i=0;i<a.length-1;i++) {
//内循环把最大值移到最后
for(int j=0;j<a.length-i-1;j++) {
if(a[j]>a[j+1]) {
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
System.out.println("\n排序后的数组元素为：");
for(int n:a) System.out.print(n+" ");
}
}Java二维数组
数组申明
1、数据类型[][] 变量名;
2、数据类型 变量名[][];
3、数据类型[] 变量名[];
数组创建
数据类型=new 数据类型[x][y];
[x]也就是一个数组中每个元素都是数组，表示有几个数组，也就是有几行,X不能省略必须填写
[y]表示每个元素数组中的数量，也就是有几列,y可以省略，但省略之后不能去使用会出现空指针异常。
申明的同时创建
int arr[][]=new int[3][3];
float farr[][]=new float[3][];
数组初始化
int arr[][]={{1,2},{3},{4,5,6}};
例子
public class ArrayDemo{
public static void main(String[] args) {
// 二维数组的声明
// 三种声明格式
// 声明int类型二维数组
int[][] intArray;
// 声明float类型二维数组
float floatArray[][];
// 声明double类型二维数组
double[] doubleArray[];
// 创建一个三行三列的int类型的数组
intArray = new int[3][3];
System.out.println("intArray数组中第三行第二列的元素为:"+intArray[2][1]);
intArray[1][2]=3;
System.out.println("intArray数组中第二行第三列的元素为:"+intArray[1][2]);
// 声明数组的同时进行创建
char[][] ch=new char[5][5];
// 创建float类型数组时，只指定行数
floatArray=new float[4][0];
// 每行相当于一个一维数组
floatArray[0]=new float[2]; // 第一行有三列
floatArray[1]=new float[3]; // 第二行有四列
System.out.println(floatArray[0][0]);
}
}
// 二维数组初始化
int[][] num= {{1,2,3},{4,5,6},{7,8,9}};
System.out.println("num数组第1行第2列的元素为:"+num[0][1]);
System.out.println("num数组的行数为："+num.length);
System.out.println("num数组的列数为："+num[0].length);
// 循环输出二维数组的内容
System.out.println("num数组的内容为：");
for(int i=0;i<num.length;i++) {
for(int j=0;j<num[i].length;j++) {
System.out.print(num[i][j]+" ");
}
System.out.println();
}
}
}
}注意：
数组是引用数据类型
创建数组时，开辟连续的内存空间
数组长度length的获取；数组下标从0开始
Arrays类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
-
给数组赋值：通过 fill 方法将指定的值分配给数组指定范围内的每个元素。
-
对数组排序：通过 sort 方法,按升序对指定对象数组元素排序。
-
比较数组：通过 equals 方法比较数组中元素值是否相等。
-
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
java方法
用来解决一类问题的代码的有序组合，即一个功能模块。
方法申明
访问修饰符 返回类型 方法名(参数列表){
方法体
}访问修饰符：public 公用的 static 静态的 等都是修饰符
返回类型：void为无参数返回 其他的类型可以是数据类型也可以是引用类型
参数列表：表示你调用的时候要填写的参数，也就是你使用这个方法的时候传入的值，这个值给方法使用，可以什么都不填即无参数但是()不能丢。
例：
System.out.println()-
println() 是一个方法。
-
System 是系统类。
-
out 是标准输出对象。
这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
无参无返回值方法
打印
public class MethodDemo {
// 打印输出的星号方法
public void printStar() {
System.out.println("*******************");
}
public static void main(String[] args) {
MethodDemo myMethodDemo=new MethodDemo();
// 调用创好的printStsr()方法，使用对象名.方法名()去调用对象
myMethodDemo.printStar();
}
}无参有返回值的方法
矩形面积
//求矩形的面积
public class Rectangle {
// 计算矩形面积方法
public int area() {
int length = 2;
int width = 1;
int getArea = length*width;
return getArea;
}
public static void main(String[] args) {
// 创建Rectangle类的对象 rc
Rectangle rc = new Rectangle();
// 使用对象名.方法名 调用方法
System.out.println("矩形面积为："+rc.area());
}
} 有参无返回值方法
大小比较
import java.util.Scanner;
public class MaxDemo {
public void max(float a,float b) {
float max;
max=a>b?a:b;
System.out.println(a+"和"+b+"的最大值为："+max);
}
public static void main(String[] args) {
MaxDemo maxDemo=new MaxDemo();
Scanner sc=new Scanner(System.in);
int a=0,b=0;
for(int i=1;i<=2;i++) {
if(i<2) {
System.out.println("请输入第"+i+"个数：");
a=sc.nextInt();
}else {
System.out.println("请输入第"+i+"个数：");
b=sc.nextInt();
}
}
maxDemo.max(a, b);
}
}有参有返回值方法
阶乘
public class FacDemo {
// 求阶乘的方法
public int fac(int n) {
int s=1;
for(int i=1;i<=n;i++) {
s=s*i;
}
return s;
}
public static void main(String[] args) {
FacDemo f = new FacDemo();
int sum = 0;
for(int i=1;i<=5;i++) {
f.fac(i);
sum = sum+f.fac(i);
}
System.out.println("1!+...+5!="+sum);
}
}数组作为方法参数
数组作为方法参数，当传参的时候，传递的是数组的名字。
public class ArrayMethod {
//打印输出数组元素的值
public void printArray(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr={10,20,30,40,50};
ArrayMethod am=new ArrayMethod();
//对象名.方法（数组名）
am.printArray(arr);
}
}方法重载
方法名相同，方法参数列表不同（数据类型和数量）
public class MathDemo{
//求两个int类型数的和
public int plus(int m,int n) {
return m+n;
}
//求两个double类型数的和
public double plus(double m,double n) {
return m+n;
}
//求数组元素的累加和
public int plus(int[] arr) {
int sum=0;
for(int i=0;i<arr.length;i++) {
sum=sum+arr[i];
}
return sum;
}
public static void main(String[] args) {
int m=5,n=10;
int[] arr= {1,2,3，4,5};
MathDemo mathDemo=new MathDemo();
System.out.println("int类型数据之和："+mathDemo.plus(m,n));
System.out.println("double类型数据之和："+mathDemo.plus(5.6,7.8));
System.out.println("数组元素之和："+mathDemo.plus(arr));
}
}方法传值
基本数据类型
方法中参数的改变不会对主方法中变量有影响：
主方法中传的值为实参，被调用的方法列表中的参数为形参，形参在调用方法中的改变并不会影响实参，主方法中变量开辟的内存地址和方法中变量的内存地址是不同的 ；也就是传值的过程当中只是把值传递过去了，但是变量本身的内存地址并没有传过去
引用数据类型
方法中对数组的改变会影响主方法中的数组：
数组是引用数据类型，与基本数据类型不同的是，调用方法时，将数组作为参数是将地址传到方法中，因此方法中的数组和主方法中的数组指向的是同一片内存空间，所以方法中对参数作的改变主方法的数组也会改变。
可变参数列表
可变参数列表作为方法参数时，如果方法的参数有多个，可变参数一定要放在最后一个参数，而且只能有一个可变参数列表作为方法参数；在方法重载中，优先调用不带可变参数的方法。
可变参数列表的底层实现是数组，可以将数组传递给可变参数列表；但是数组作为方法参数时，是不能将多个值传递给数组的，所以定义方法时方法名相同参数分别是数组和可变参数列表的两个方法是重复的（会报错）不是重载。
当传入方法的参数数量不确定时，可以考虑使用可变参数列表。
public class ArgsDemo {
public boolean search(int n, int... arr) {
for (int a:arr) {
if (a == n) {
System.out.println("找到了！");
return true;
}
}
System.out.println("没找到！");
return false;
}
public static void main(String[] args) {
ArgsDemo ag = new ArgsDemo();
int[] arr = {1,2,3,4,5};
ag.search(3, 1,2,3,4,5);
ag.search(3, arr);
}
}
扫一扫
8500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
