目录
数组定义
数组定义的三种格式
数组类型[] 数组名=new 数组类型 [数组长度]
数组类型[] 数组名=new 数组类型 []{数组元素}
数组类型[] 数组名={数组元素}
关键字new：用来创建对象，给对象在内存中申请空间
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
int[] array = new int[3];
int[] str = new int[]{1, 2, 3, 4};
}arr数组元素被初始化为1，2，3，4
array数组中3个元素全部自动默认初始化为0
str数组中的元素被初始化为1，2，3，4
数组的存储
JVM的内存划分
java虚拟机栈---类似于我们c语言的栈，可以存放局部变量
本地方法栈---运行c/c++代码，jvm本身即是用c/c+写出来的
方法区---可以放静态变量
堆---一般放对象
程序计数器---存放下一条指令
数组存储
以int[] arr = {1, 2, 3, 4};为例，这个语句可以划分为两部分
int[] arr;
arr=new int[] {1, 2, 3, 4};
int []arr;声明了一个变量arr，arr类型是int []。arr是一个局部变量，存储在栈中。
arr=new int[] {1, 2, 3, 4};new int[] {1，2，3，4}创建了一个数组，并将元素初始化，将数组首元素的地址赋给了变量arr，程序运行期间，可以通过arr来引用数组。{1，2，3，4}存储在堆中
数组的基本操作
数组遍历
java中通过”数组名.length"就可以获取数组长度
通过数组下标来访问数组元素，下标从0开始。
public static void main(String[] args) {
int []arr=new int []{1,2,3,4};
System.out.println(arr.length);
for (int i = 0; i < arr.length ; i++) {
System.out.print(arr[i]+" ");
}
}for each循环
Java支持一个简便的for循环，称之为for-each循环，不使用下标变量就可以顺序的遍历整个数组。
语法：for（元素类型 元素 ：数组名）｛
语句体；
｝
元素类型要和数组元素类型相同
public static void main(String[] args) {
int []arr=new int []{1,2,3,4};
System.out.println(arr.length);
for(int x:arr) {
System.out.print(x+" ");
}数组转化为字符串
借用Array.toString
包： import java.util.Arrays;
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4};
System.out.println(Arrays.toString(arr));
}数组拷贝
1.for循环遍历拷贝
public static int [] Mycopy(int []arr){
int []copy=new int[arr.length];
for (int i = 0; i <arr.length ; i++) {
copy[i]=arr[i];
}
return copy;
}
public static void main(String[] args) {
int []arr={1,2,3,4};
int []copy=Mycopy(arr);
System.out.println(Arrays.toString(copy));
}2.
public static void main(String[] args) {
int []arr={1,2,3,4};
int []copy=Arrays.copyOf(arr,arr.length);//以指定的长度复制arr数组
System.out.println(Arrays.toString(copy));
} 鼠标选中copyof，鼠标右键打开，找到Go To，选中Declartion or Usages,或者 鼠标选中copyof，按ctrl+B，可以打开jdk源码
这就是Arrays.copy的源码
3.指定范围的复制
from---开始复制，to---终止复制 [左闭区间，右开区间）
public static void main(String[] args) {
int []arr={1,2,3,4};
int []copy=Arrays.copyOfRange(arr,0,2);//下标[0,2），元素1，2
System.out.println(Arrays.toString(copy));
}
4.我们发现jdk的以上两个源码中，都出现出现了
这也是一个拷贝方法
public static void main(String[] args) {
int []arr={1,2,3,4};
int []copy=new int[arr.length];
System.arraycopy(arr,1,copy,2,2);
//从arr下标是1的元素开始，拷贝2个元素到copy数组，从copy数组下标为2的地方开始赋值
//0 0 2 3
System.out.println(Arrays.toString(copy));
}5. 数组名.clone()
public static void main(String[] args) {
int []arr={1,2,3,4};
int []copy=arr.clone();
System.out.println(Arrays.toString(copy));
}常见错误
空指针异常
通过变量来引用一个数组，如果说 arr=null，那么意味着arr不指向任何一个数组，此时通过该变量访问数组的任何信息都会出现错误---空指针异常
public static void main(String[] args) {
int []arr=null;
System.out.println(arr.length);
}
数组下标越界
public static void main(String[] args) {
int []arr={1,2,3};
for (int j = 0; j <= arr.length; j++) {
System.out.println(arr[j]);
}
}
数组传参
1.数组传参
形参变量得到实参变量的值，也即是数组的首元素地址，如果形参变量的值不更改，那么可以通过形参改变数组元素。
public static void fun(int []arr) {
arr=new int[]{3,2};
}
public static void Fun(int []arr) {
arr[0]=4;
}
public static void main(String[] args) {
int []arr={1,2,3,4};
System.out.print(Arrays.toString(arr));
System.out.println();
fun(arr);
System.out.print(Arrays.toString(arr));
System.out.println();
int []brr={1,2,3,4};
System.out.print(Arrays.toString(brr));
System.out.println();
Fun(brr);
System.out.print(Arrays.toString(brr));
}结果如下：
2.整数交换
结果：a=10，b=20;
public static void Swap(int a,int b){
int tmp=a;
a=b;
b=tmp;
}
public static void main(String[] args) {
int a=10,b=20;
System.out.println("交换前a="+a+"b= "+b);
Swap(a,b);
System.out.println("交换后a="+a+"b= "+b);
}使用引用类型更改
结果：a=20，b=10;
public static void Swap(int []str){
int tmp=str[0];
str[0]=str[1];
str[1]=tmp;
}
public static void main(String[] args) {
int a=10,b=20;
int []str={a,b};
System.out.println("交换前a="+str[0]+"b= "+str[1]);
Swap(str);
System.out.println("交换后a="+str[0]+"b= "+str[1]);
}3.数组作为函数返回值
将数组元素扩大二倍存放到一个新数组里面，且不改变原数组的元素值
public static int [] Double(int []arr) {
int[] str = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
str[i] = arr[i] * 2;
}
return str;
}
public static void main(String[] args) {
int []arr={1,2,3,4};
int []str= Double(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(str[i]+" ");
}
}模拟实现Arrays.toString函数
利用字符串的“+”
public static String Mytostring (int []arr) {
if(arr==null)
return null;
String str = "[";
for (int i = 0; i < arr.length; i++) {
str += arr[i];
if (i < arr.length - 1)
str += ",";
}
str+="]";
return str;
}
public static void main(String[] args) {
int []arr={1,2,3,4,9};
String str=Mytostring(arr);
System.out.println(str);
}二维数组
二维数组的存储
c语言中，二维数组可以使用按行存储或者按列存储（大多按行存储）
int arr[2][3]={1，2，3，5，6，7}
在c语言中如下存储，arr[0],arr[1]存放的将会分别是数组{1，2，3}，数组{5，6，7}的地址
| 1 | 2 | 3 |
| 5 | 6 | 7 |
在java中，arr[0],arr[1]存放的将会分别是数组{1，2，3}，数组{5，6，7}的地址
所以说通过arr[0]可以引用{1，2，3}这个数组， 通过arr[1]可以引用{5，6，7}这个数组
打印二维数组
public static void main(String[] args) {
int [][]array={{1,2,3},{4,5,6}};
// System.out.println(array.length);//2 行 array[0],array[1]两个元素
// System.out.println(array[0].length);//3 列 array[0]数组存放{1，2，3}
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j < array[0].length; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}public static void main(String[] args) {
int [][]array={{1,2,3},{4,5,6}};
for (int []arr:array
) {
for (int x:arr
) {
System.out.print(x+" ");
}
System.out.println();
}
}
使用方法
public static void main(String[] args) {
int [][]arr={{1,2,3},{5,6,7}};
System.out.println(Arrays.deepToString(arr));
}java中数组和c的差异
1.自动补0的问题
int [][]array={{1,2},{5,6,7}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
不会自动补0
而c语言中
直接报错误，arr必须至少有列长度
更改之后
#include<stdio.h>
int main()
{
int arr[][3] = { {1,2},{4,5,6} };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
printf("%d ", arr[i][j]);
}
return 0;
} 
自动补0
2.可以省略行列不同
java中只可以省略列，不可以省略行
c语言中只可以省略行，不可以省略列
java先对二维数组分配空间，也就是先要分配arr[0],arr[1]的空间，然后才对arr[0],arr[1]这两个一维数组分配空间，所以要知道行
在c语言中，通过直接赋值的方式传入元素，再加上c语言自动补0，通过列可以计算出行，如果只给行无法计算出列数
3.不规则的二维数组
public static void main(String[] args) {
int[][] array = new int[2][];
array[0] = new int[]{1, 2};
array[1] = new int[3];
array[1][0] = 4;
array[1][1] = 5;
array[1][2] = 6;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
135
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
