java中数组总结

1.数组的基本用法

1.1数组的创建

数组本质上就是让我们能 “批量” 创建相同类型的变量， 数组的内存是连续的。
数组的创建：

// 动态初始化 数据类型[] 数组名称 = new 数据类型 [长度] { 初始化数据 };
// 静态初始化 数据类型[] 数组名称 = { 初始化数据 }
//示例
int[] arr = new int[3]{1, 2, 3};
int[] arr = {1, 2, 3};

1.2 数组的使用

代码示例: 获取长度 & 访问元素

int[] arr = {1, 2, 3};
// 获取数组长度 

System.out.println("length: " + arr.length);		 // 执行结果: 3
// 访问数组中的元素 
System.out.println(arr[1]);         // 执行结果: 2 
System.out.println(arr[0]);         // 执行结果: 1 
arr[2] = 100; 
System.out.println(arr[2]);      // 执行结果:100

使用 arr.length 能够获取到数组的长度 . 这个操作为成员访问操作符. 在面向对象中会经常用到.
代码示例：遍历数组

//使用for循环遍历
int[] arr = {1, 2, 3};
 for (int i = 0; i < arr.length; i++) { 
    System.out.println(arr[i]);
     }
// 执行结果
 1
 2 
 3

//使用foreach循环遍历
int[] arr = {1, 2, 3};
 for (int x : arr) {   
  System.out.println(x);
   }
// 执行结果 
1 
2
3

for循环和foreach都能遍历数组，最大的区别是使用for循环能获得数组的下标，而forerch不能。

2. 数组作为方法的参数

代码示例：打印数组内容

public static void main(String[] args) { 
int[] arr = {1, 2, 3};    
printArray(arr); 
}
public static void printArray(int[] a) {    
for (int x : a) {
System.out.println(x);    
	} 
}

// 执行结果 
 1
 2 
 3 

在这段代码中int[] a 是函数的形参, int[] arr 是函数实参.

2.1引用类型的理解（重点）

数组是引用类型，引用类型存放的是地址，而不是实际值。
代码示例：参数为基本类型

public static void main(String[] args) {    
int num = 0;    
func(num);    
System.out.println("num = " + num);
 }
 
public static void func(int x) {   
 x = 10;    
 System.out.println("x = " + x);
  }
  
// 执行结果 
x = 10
num = 0 

我们会发现, 修改形参 x 的值, 不影响实参的 num 值.
代码示例：参数为基本类型

public static void main(String[] args) {     
int[] arr = {1, 2, 3};     
func(arr);     
System.out.println("arr[0] = " + arr[0]); 

public static void func(int[] a) {     
a[0] = 10;     
System.out.println("a[0] = " + a[0]); } 
 
// 执行结果 
a[0] = 10 
arr[0] = 10 

我们发现, 在函数内部修改数组内容, 函数外部也发生改变. 此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参.

Jdk（Java developmentkit） java开发工具
Jre（java runtime environment）Java运行环境
Jvm （Java virtual machine）虚拟机
这三者从上到下为包含关系，我们java程序都是在jvm中运行的。
jvm主要包含5个部分

1. 程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.
2. 虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址 的引用就是在这里保存.
3. 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部 变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
4. 堆(Heap):JVM所管理的大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )
5. 方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域

需要特别注意的是在Jdk1.7及之前，常量值存放在方法区，jdk1.7之后，存放在堆上

数组作为方法的返回值

代码示例: 写一个方法, 将数组中的每个元素都 X 2

// 直接修改原数组 class Test {    
 public static void main(String[] args) {        
  int[] arr = {1, 2, 3};         
  transform(arr);         
  printArray(arr);  
     } 
 
    public static void printArray(int[] arr) {         
    for (int i = 0; i < arr.length; i++) {             
    System.out.println(arr[i]);       
   	   }   
        } 
 
    public static void transform(int[] arr) {         
    for (int i = 0; i < arr.length; i++) {            
     arr[i] = arr[i] * 2;       
    		   }    
    	      }
         }

这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.

// 返回一个新的数组 class Test {     
public static void main(String[] args) {         
int[] arr = {1, 2, 3};         
int[] output = transform(arr);         
printArray(output);   
  } 
 
    public static void printArray(int[] arr) {        
     for (int i = 0; i < arr.length; i++) {            
      System.out.println(arr[i]);     
          }   
         } 
 
 public static int[] transform(int[] arr) {       
   int[] ret = new int[arr.length];        
    for (int i = 0; i < arr.length; i++) {            
    ret[i] = arr[i] * 2;         }         
        return ret;    
         }
          } 

这样的话就不会破坏原有数组了. 另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.