java中的数组及其使用查找

1.定义

数组：相同类型的数据合集成为数组，数组的内存是连续的。

int[] array1 = {1,2,3,4,5};
int[] array2 = new int[]{1,2,3,4,5};
int[] array3 = new int[5];

new 之后就会产生一个新的对象，通过new是动态初始化；array1，array2，array3被称为“引用”，用来存放对象的地址。

2.数组的使用

2.1 获取数组的长度：

array = {1,2,3};
System.out.println(arr[1]);         // 执行结果: 2
System.out.println(arr[0]);         // 执行结果: 1 

arr[2] = 100;
System.out.println(arr[2]);         // 执行结果: 100

2.3 下标越界

下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常(在运行期间).
代码示例：

int[] array = {1, 2, 3}; 
System.out.println(array[100]);
// 执行结果
 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100       
 at Test.main(Test.java:4

2.4 遍历数组

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.

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

当定义好数组后，没有初始化，默认值为0。若数组当中是引用类型，就是null。

2.5 for-each 遍历数组

for(表达式1：表达式2）{
}

表达式1：数组当中的变量及其类型
表达式2：数组名

int[] arr = {1, 2, 3};
for (int x : arr) {    
System.out.println(x);
}
// 执行结果
1 
2 
3

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错
2.5.1 for循环和for-each的区别？
for-each不能通过下标去访问数组
2.5.2 当定义好数组之后，没有初始化，默认值为0；数组当中如果是引用类型就是null。

3.数组作为方法的参数

3.1 基本用法

代码示例： 打印数组内容

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 是函数实参.

3.2 引用类型

代码示例：

	public static void func(int x) {
        x = 10;
    }
    // 按值传递
    public static void func2(int[] array) {
        array[0] = 99;
   // 按引用（址）传递
	}

代码示例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 值

代码示例2：参数传数组类型

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 是一个 “引用” ，当传参的时候, 是按照引用传参.

3.3 Java中的内存分析

Java虚拟机栈：局部变量
本地方法栈：native方法：底层由C/C++实现。特点：快
程序计数器：指令
方法区：静态变量 类的信息
栈：对象 new关键字
常量池：存放字符串常量 String str = “hello”

示例：

int[] array1 = {1,2,3,4,5};
int[] array2 = new int[]{1,2,3,4,5};
int[] array3 = new int[5];

图片实例：

4.数组转字符串

import java.util.Arrays 
int[] arr = {1,2,3,4,5,6}; 
String newArr = Arrays.toString(arr);
System.out.println(newArr); 

Arrays.toString(array)：将数组以字符串的形式输出。
Arrays:Java当中操作数组的工具类。所有的工具类在使用时必须导入包。java.util.Arrays 在idea中会自动导入

5. 数组拷贝

5.1 for循环实现

int[] array={1,2,3,4,5};
int[] array2=new int[array.length];
System.out.println(Arrays.toString(array));
  for(int i=0;i<array.length;i++){
   array2[i]=array[i];
   }
System.out.println(Arrays.toString(array2));
}

5.2 arraycopy 实现

速度快，底层由C/C++编写，被native修饰

int[] array = {1, 2, 3, 4, 5};
int[] array2 = new int[array.length];
System.out.println(Arrays.toString(array));
System.arraycopy(array, 0, array2, 0, array.length);
System.out.println(Arrays.toString(array2));

5.3 Arrays.copyOf 实现（深拷贝）

速度慢，内部调用了System.arraycopy

int[] array = {1, 2, 3, 4, 5};
int[] array2 = new int[array.length];
System.out.println(Arrays.toString(array2));
array2 = Arrays.copyOf(array, array.length);
System.out.println(Arrays.toString(array2));

深拷贝： 拷贝原有 数组中的所有元素到新数组中，修改原数组， 不会影响到新数组.

5.6 array.clone 实现

数组名.clone()：该数组名指的是需要拷贝的数组，即原数组

int[] array = {1, 2, 3, 4, 5};
int[] array2 = new int[array.length];
array2 = array.clone();
System.out.println(Arrays.toString(array2));

总结：
以上4种拷贝方式，若数组当中是简单类型，是深拷贝；若数组当中存放的是引用类型，则是浅拷贝

6. 查找数组当中的元素

6.1 顺序查找

public static void main(String[] args) {     
	int[] arr = {1,2,3,10,5,6};     
	System.out.println(find(arr, 10)); } 
 
 public static int find(int[] arr, int toFind) {     
	for (int i = 0; i < arr.length; i++) {         
		if (arr[i] == toFind) {            
		return i;         
		}     
	}     
	return -1;  
// 表示没有找到 
} 
 
// 执行结果 
3 

6.2 二分查找

public static void main(String[] args) {     
	int[] arr = {1,2,3,4,5,6};     
	System.out.println(binarySearch(arr, 6)); } 
 
	public static int binarySearch(int[] arr, int toFind) {     
		int left = 0;      
		int right = arr.length - 1;     
		while (left <= right) {         
		 int mid = (left + right) / 2;         
		 if (toFind < arr[mid]) {             // 去左侧区间找             
			right = mid - 1;         
		 } else if (toFind > arr[mid]) {      // 去右侧区间找             
			left = mid + 1;         
			} else {             // 相等, 说明找到了             
		return mid;         
		}     
	}     // 循环结束, 说明没找到    
   return -1; 
} 
 
// 执行结果 
5 

7.二维数组

7.1 定义

规则的：

int [][] array={{1,2},{3,4},{5,6}};
int [][] array=new int [][] {{1,2},{3,4},{5,6}};
int [][] array=new int[3][2];

不规则的：

int [][] array=new int[3][];
int [][] array={{1},{3,4},{5,6}};//不规则的二维数组

Arrays.deepToString(array)：将二维数组转换成字符串进行打印。

※ 要注意，在使用不规则数组定义时，若使用循环语句，语句应正确写成 i<array[i].length，防止数组越界。