标签：var1 var0 int Arrays 数组 Java public

数组可以理解为 固定大小的、用来存储 相同类型 数据元素的数据容器，是一种数据类型（引用类型）。

数组起步

数组创建

• 静态初始化

预先知道数组内容，创建数组时即指定数组元素的值。

/*
	数据类型[] 数组变量名 = {元素1，元素2，...,元素n};
	数据类型[] 数组变量名 = new 数据类型[]{元素1，元素2，...,元素n};
*/
int[] arr1 = {1,2,3,4};
int[] arr2 = new int[]{1,2,3,4};

• 动态初始化

预先不知道数组内容，创建数组时指定数组长度，数组元素初始化为默认值（参考数据类型）。

/*
	数据类型[] 数组变量名 = new 数据类型[数组长度];
*/
String[] arrStr = new String[3]; // String 默认值 null

数组访问与操作

可以通过下标索引访问数组中的元素，索引从 0 开始，最大值 = 数组长度 - 1，可通过 数组.length 属性获得数组长度。

• 如果访问时索引超过最大值，会报 java.lang.ArrayIndexOutOfBoundsException （数组下标越界异常）。

• 如果数组变量的引用为 null ，会报 java.lang.NullPointerException（空指针异常）。

int[] arr1 = {1,2,3};
int ele = arr1[0];
arr1[1] = 12;
System.out.println(arr1.length);

数组遍历

• 普通循环遍历

int[] datas = {1, 2, 4, 545, 11, 32, 13131, 4444};

for(int i = 0; i < datas.length; i++) {
  System.out.println(datas[i]);
}

• 增强 for

JDK1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环。

int[] datas = {1, 2, 4, 545, 11, 32, 13131, 4444};

for(int ele: datas) {
  System.out.println(ele);
}

多维数组

多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，每个元素都是一个一维数组。

二维数组本质上是行列集合，要确定某一个元素需要行索引和列索引来进行定位。

int[][] arr1 = {{1,2},{3,4,5},{6}}; // 静态初始化
int[][] arr2 = new int[3][4]; // 动态初始化

System.out.println(arr1[1][1]); // 4

/*
	打印一个 10 行的杨辉三角
*/

int[][] yangHui = new int[10][];

for(int i = 0;i < yangHui.length; i++){
	yangHui[i] = new int[i+1];
	for(int j = 0; j < yangHui[i].length; j++){
		if(j == 0 || j == yangHui[i].length - 1) {
			yangHui[i][j] = 1;
		} else {
			yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
		}
		System.out.print(yangHui[i][j] + " ");
	}
	System.out.println("");
}

内存分析

int[] arr1 = {1,2,3,4}; // arr1 实际指向数组空间的首地址

Arrays 常用方法

Arrays 位于 java.util 包中，包含操纵数组的各种静态方法。

• toString 数组转字符串

对于多维数组，使用 Arrays.deepToString。

// 基本类型，此处例举 int
public static String toString(int[] arr)

public static String toString(Object[] arr)

import java.util.Arrays;

public class ArrayDemo {

    public static void main(String[] args) {
        int[] arr1 = {3,1,5,4,2,8,9};
        System.out.println(arr1);
        System.out.println(Arrays.toString(arr1));

        Human[] arr2 = {new Human("齐贝林",33)};
        System.out.println(arr2); // [Lcom.hello.base.Human;@1b6d3586
        System.out.println(Arrays.toString(arr2));
    }

}

class Human {
    public String name;
    public int age;

    public Human(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Human{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• sort 数组排序

sort 方法默认是从小到大排序，如果希望按照从大到小排序，可以通过 Comparable 接口或者 Comparator 外部比较器接口的比较方法实现。

// 基本类型，此处例举 int
public static void sort(int[] a)

// 对象类要实现 Comparable 接口
public static void sort(Object[] a)

// 通过 Comparator 外部比较器接口比较
public static <T> void sort(T[] var0, Comparator<? super T> var1)

import java.util.Arrays;
import java.util.Comparator;

public class ArrayDemo {

    public static void main(String[] args) {
        int[] nums = {2,5,0,4,6,-10};
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        Human[] arrHuman1 = {new Human("龟仙人",100),
                new Human("齐贝林",33),
                new Human("雄霸",66)};
        System.out.println(Arrays.toString(arrHuman1));

		// 按年龄从小到大
        Arrays.sort(arrHuman1, new Comparator<Human>() {
            @Override
            public int compare(Human t1, Human t2) {
				// 返回 -1 表示 t1 小于 t2,0 表示 t1 等于 t2,1 表示 t1 大于 t2
                return t1.age - t2.age;
            }
        });
        System.out.println(Arrays.toString(arrHuman1));

		// 按年龄从大到小
        Arrays.sort(arrHuman1, new Comparator<Human>() {
            @Override
            public int compare(Human t1, Human t2) {
                return t2.age - t1.age;
            }
        });
        System.out.println(Arrays.toString(arrHuman1));
    }

}

class Human {
    public String name;
    public int age;

    public Human(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Human{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• binarySearch 二分查找指定元素

数组必须有序。

如果元素存在，返回第一次找到的元素下标，如果不存在，返回 -（插入点下标 + 1）。

/*
	基本类型，此处例举 int
	var0 数组
	var1 目标元素
*/
public static int binarySearch(int[] var0, int var1) {
	return binarySearch0((int[])var0, 0, var0.length, (int)var1);
}

private static int binarySearch0(int[] var0, int var1, int var2, int var3) {
	int var4 = var1; // 起始位置
	int var5 = var2 - 1; // 结束位置

	while(var4 <= var5) {
		int var6 = var4 + var5 >>> 1;  // 中间位置
		int var7 = var0[var6];
		if (var7 < var3) { // 大于中间位置的值
			var4 = var6 + 1;
		} else {
			if (var7 <= var3) { // 等于中间位置的值
				return var6;
			}
			// 大于中间位置的值
			var5 = var6 - 1;
		}
	}

	return -(var4 + 1);
}

int[] arr = {0,2,3,4,10};
System.out.println(Arrays.binarySearch(arr,2)); // 1
System.out.println(Arrays.binarySearch(arr,5)); // -5

• copyOf & copyOfRange 数组拷贝

基于原数组，复制一个新数组，实际是调用 System.arraycopy 方法进行拷贝。

/*
	src - 源数组。 
	srcPos - 源数组中的起始位置。 
	dest - 目标数组。 
	destPos - 目标数组中的起始位置。 
	length - 要复制的数组元素的数量。 
*/
public static void arraycopy(Object src,int srcPos,Object dest, int destPos,int length)

/*
	基本类型，此处例举 int
	var0 - 源数组
	var1 - 拷贝长度
*/
public static int[] copyOf(int[] var0, int var1) {
	int[] var2 = new int[var1];
	System.arraycopy(var0, 0, var2, 0, Math.min(var0.length, var1));
	return var2;
}

/*
	var0 - 源数组
	var1 - 拷贝起始位置
	var2 - 拷贝终点位置（不抱含）
*/
public static int[] copyOfRange(int[] var0, int var1, int var2) {
	int var3 = var2 - var1;
	if (var3 < 0) {
		throw new IllegalArgumentException(var1 + " > " + var2);
	} else {
		int[] var4 = new int[var3];
		System.arraycopy(var0, var1, var4, 0, Math.min(var0.length - var1, var3));
		return var4;
	}
}

int[] arrA = {3,11,5,7,2,1,9,6,12,1};
int[] arrB = Arrays.copyOf(arrA,arrA.length);
int[] arrC = Arrays.copyOfRange(arrB,1,3);
System.out.println(Arrays.toString(arrB));
System.out.println(Arrays.toString(arrC));

• hashCode 哈希值

对于多维数组，使用 Arrays.deepHashCode。

public static int hashCode(int[] var0) {
	if (var0 == null) {
		return 0;
	} else {
		int var1 = 1;
		int[] var2 = var0;
		int var3 = var0.length;

		for(int var4 = 0; var4 < var3; ++var4) {
			int var5 = var2[var4];
			var1 = 31 * var1 + var5;
		}

		return var1;
	}
}

• equals 数组比较

数组长度和数组元素都相等时才相等。

对于多维数组，使用 Arrays.deepEquals。

public static boolean equals(int[] var0, int[] var1) {
	if (var0 == var1) {
		return true;
	} else if (var0 != null && var1 != null) {
		int var2 = var0.length;
		if (var1.length != var2) {
			return false;
		} else {
			for(int var3 = 0; var3 < var2; ++var3) {
				if (var0[var3] != var1[var3]) {
					return false;
				}
			}

			return true;
		}
	} else {
		return false;
	}
}

• asList 转集合

import java.util.AbstractList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

public class ArrayDemo {

    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        String[] arr2 = {"1","2","3"};
		// List<Object> list1 = Arrays.asList(arr1);
        List<Object> list1 = Demo.asList(arr1);
        List<Object> list2 = Demo.asList(arr2);
        for (Object obj1:list1) {
            System.out.println(obj1.toString());
        }
        for (Object obj2: list2) {
            System.out.println(obj2.toString());
        }
    }

}

/**
	仿写 Arrays 的 asList 方法
*/
class Demo{
	/*
		T...args，可以理解为数组，T 泛型，因此只能是引用类型数组
		基本类型会将整个数组作为 args 的元素
	*/
    public static <T> List<T> asList(T...args){
        return new Demo.DemoList(args);
    }

    public static class DemoList<E> extends AbstractList<E> {
        private final E[] a;

        DemoList(E[] var1) {
            this.a = Objects.requireNonNull(var1);
        }

        @Override
        public E get(int var1) {
            return this.a[var1];
        }

        @Override
        public int size() {
            return this.a.length;
        }
    }
}

标签：var1,var0,int,Arrays,数组,Java,public
来源： https://www.cnblogs.com/knhap/p/16047568.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。