Java数组
数组存储
public static void main(String[] args) {
int n = 5;
n = 6;
int [] arr;
arr = new int[3];// 创建数组
}
内存图：
创建数组声明的是一个引用类型
栈存放基本数据类型和引用
堆存放对象（数组对象、对象）
所以创建一个数组分配好空间后栈中的数组引用堆中的数组对象，栈中存放数组的地址
创建和使用数组
动态初始化
我们指定大小，系统赋值。
public static void main(String[] args) {
int [] arr;// 声明数组
// int arr [];
// 初始化：开辟空间赋值
// 1. 动态初始化方式： 我们指定数组大小，系统指定值。
arr = new int[3];// 创建数组
// 使用：
/*
* 初始值：
* 整数： 0
* 浮点： 0.0
* 布尔：false
* 字符：‘\u0000’
* 字符串：null
*/
System.out.println(arr[0]);// 0
System.out.println(arr[1]);// 0
System.out.println(arr[2]);// 0
// System.out.println(arr[3]);// 数组越界异常
// 修改数组元素的值
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
System.out.println(arr[0]);// 11
System.out.println(arr[1]);// 22
System.out.println(arr[2]);// 33
}
静态初始化
我们指定值，系统指定大小。
// 静态初始化的方式:我们指定值，系统指定大小
int [] arr = {11,22,33};// 一行
// 获得数组的长度
System.out.println(arr.length);// 3
int [] arr1 = new int[]{11,22,33};// 一行
int [] arr2 ;
arr2 = new int[]{11,22,33};// 两行
注意事项
1） 存储的是相同数据类型的一组数；
2） 数组的长度是固定的。
3） 数组的元素可以是基本类型 也可以是引用
数组的遍历
public static void main(String[] args) {
int [] arr = {11,22,33};
// 展示所有元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
// 简化：
// 1.基本for循环
for(int i = 0; i < arr.length ; i ++){// 0 ,1 ,2
System.out.println(arr[i]);// 0,1,2
}
System.out.println(arr);// [I@15db9742 输出的是数组地址
// 2. 增强for(遍历集合和数组)
/*
* for(类型 变量名:遍历的数组的名字){
* }
*/
for(int a:arr){
System.out.println(a);
}
/*
* 增强for:
* 优点：语法简洁
* 注意:
* 1.只能顺序遍历
* 逆序遍历用基本for
* 2.只能遍历数组的所有元素
* 范围访问用基本for
* 3.不能修改元素
* 修改元素用基本for
*/
System.out.println("------逆序--------------");
// 逆序
for(int i = arr.length - 1; i >= 0; i --){//
System.out.println(arr[i]);
}
System.out.println("-------范围--------");
// 22,33,44
for(int i = 1; i< 4; i ++){
System.out.println(arr[i]);
}
System.out.println("------修改---------");
// 每个元素都+2
for(int a : arr){
a = a + 2;// 错误，不能修改元素 如果遍历的是对象数组，可以对每个对象的属性进行修改
}
for(int i = 0; i < arr.length ; i ++){
arr[i] = arr[i] + 2;// 修改元素
}
for(int a : arr){
System.out.println(a);
}
}
复制数组
public static void main(String[] args) {
int [] arr = {11,22,33,44,55};
// 方式一：依次将数组元素复制到新数组中
int [] arr1 = new int[arr.length];
for(int i = 0; i < arr.length; i ++){
arr1[i] = arr[i];
}
// 方式二：使用java.lang.System提供的arraycopy方法
int [] arr2 = new int[arr.length];
/*
* 复制数组：
* src :源数组
* srcPos:源数组的起始位置
* dest:目标数组
* destPos:目标数组的起始位置
* length:复制的个数
*/
System.arraycopy(arr, 0, arr2, 0, 5);
// 方式三：java.lang.Object 的clone方法
int [] arr3 = arr.clone();// Object类 复制克隆
System.out.println(arr3);
System.out.println(arr);
// 方式四：
int [] arr4 = Arrays.copyOf(arr, 5);
for(int a : arr4){
System.out.println(a);
}
}
Arrays
使用java.util.Arrays类
常用方法
①toString
②Sort
③binarySearch
④equals
⑤fill
⑥copyOf
二分查找的源码:
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
比较两个数组是否相等 equals()
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
return false;
return true;
}
方法的使用：
public static void main(String[] args) {
int [] arr = {11,33,22};
// 1. 把数组转换成字符串
String s = Arrays.toString(arr);
System.out.println(s);// [11, 33, 22]
// 2. 升序排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));// [11, 22, 33]
// 3. 二分查找法(前提：升序排序)
// 查找元素是否存在，存在范围索引，不存在返回负数 -插入点-1
System.out.println(Arrays.binarySearch(arr, 22));//1
System.out.println(Arrays.binarySearch(arr, 55));// -4
// 4. 判断两个数组是否相等，相等 true （比较的是数组的元素）
// 只要两个数组对应位置的元素都相等并且长度都相等，那么两个数组相等
int [] arr1 = {1,2,3};
int [] arr2 = {1,2,3};
System.out.println(Arrays.equals(arr1, arr2));// true
int [] arr3 = {1,2,4};
int [] arr4 = {1,2,3};
System.out.println(Arrays.equals(arr3, arr4));// false
// 5.填充数组
int [] arr5 = {1,2,3};
System.out.println(Arrays.toString(arr5));// [1, 2, 3]
Arrays.fill(arr5, 999);
System.out.println(Arrays.toString(arr5));// [999, 999, 999]
// 6. 数组的复制
int [] arr6 = {1,2,3,4,5};
int [] arr7 = Arrays.copyOf(arr6, 5);
System.out.println(Arrays.toString(arr7));// [1, 2, 3, 4, 5]
System.out.println(arr6);
System.out.println(arr7);
}
二维数组
int [] arr = new int[3];//0x12a
int [][] arr1 = new int[2][2];//0x23c
//arr1[0]和arr1[1]各有一个一维数组地址
public static void main(String[] args) {
// 动态初始化
int [][] arr= new int[3][2];
// 赋值
// 控制台输入
Scanner in= new Scanner(System.in);
System.out.println("-- 给数组赋值：");
for(int i = 0; i < arr.length; i ++){
for(int j = 0; j < arr[i].length; j ++){
arr[i][j] = in.nextInt();
}
}
// 输出
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j ++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
public static void main(String[] args) {
// 静态初始化
// int [][] arr = {{12,2},{5,8},{14,12}};
int [][] arr = new int[][]{{12,2},{5,8},{14,12}};
// 输出 基本for
for(int i = 0; i < arr.length; i ++){
for(int j = 0 ; j < arr[i].length; j ++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
// 增强for
for(int [] ar:arr){
for(int a : ar){
System.out.print(a + "\t");
}
System.out.println();
}
}
不规则数组
动态初始化：
public static void main(String[] args) {
int [][] arr = new int[3][];
// *** 给一维数组分配空间***
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[4];
//*********************
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
// 控制台输入：
Scanner superman = new Scanner(System.in);
System.out.println("-- 赋值：");
for(int i = 0; i < arr.length; i ++){
for(int j = 0; j < arr[i].length; j ++){
arr[i][j] = superman.nextInt();
}
}
// 输出
for(int [] ar : arr){
for(int a : ar){
System.out.print(a + "\t");
}
System.out.println();
}
}
静态初始化：
public static void main(String[] args) {
// TODO Auto-generated method stub
// int [][] arr = {{12,2},{5,8,6},{14,12,44,3}};
int[][] arr = new int[][]{{12,2},{5,8,6},{14,12,44,3}};
}
