数组

最新推荐文章于 2024-09-04 22:54:45 发布

转载最新推荐文章于 2024-09-04 22:54:45 发布 · 68 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/zhanghongjun289/blog/668637

2019独角兽企业重金招聘Python工程师标准>>>

1、数组

对比基本数据类型变量，数组的声明与创建

基本数据类型变量声明格式：

数据类型变量名;

int num;

数组声明格式1：

数据类型[] 数组名;

byte[] arr1;

格式2：

数据类型数组名[];

byte arr1[];

基本数据类型变量赋值：

变量名 = 变量值;

数组的赋值：

数组名 = 数组值;

1、new 数据类型[length]; ---> length:数组的长度，是一个正整数，确定数组的长度

2、new 数据类型[]{value1,v2,v3 ...};//每当使用new是，就是在堆中分配空间

打印数组的引用格式：[B@139a55

[ ---- 数组

B ---- 数据类型

@ ---- 分隔号

十六进制散列码 ----> 数组的堆中空间的地址值

class ArraysDemo00
{
	public static void main(String[] args){
		byte num = 10;
		//创建了一个数组类型的变量，有多个数据，数据都是byte类型的
		//byte[] nums = {1,2,3,4,5,6};
		int i;
		i = 10;
		//数组的声明
		byte[] arr1;
		byte arr2[];
		//分配空间，空间内有5份，每份都是一个byte
		arr1 = new byte[5];
		//分配空间，空间内有三份，分别对应的值是1,2,3
		arr2 = new byte[]{1,2,3};
		System.out.println(arr1);//[B@139a55
		System.out.println(arr2);//[B@1db9742

		int[] arr3;
		arr3 = new int[3];
		System.out.println(arr3);//[I@106d69c
	}
}

/**
	数组的相关操作：
	数组的容量一旦分配，就不可以变更

	注意：
		1、取出数组内的元素时，数组为每一个元素标注了索引
		2、索引从0开始，以1递增，最大索引是 数组长度减一；
		3、如果是用的索引不在范围之内 ---- 抛出异常
		   ArraysIndexOutofBounds -------- 数组索引越界
*/
class ArraysDemo01
{
	public static void main(String[] args){
		byte[] arr1 = new byte[5];
		//增 ----- 没有
		//删 ----- 没有删的动作
		//arr1 = null; ---- 告知虚拟机，垃圾回收器可以内存回收了
		//查 ----- 数组中的元素，通过索引获取
		//格式：数组名[索引];
		byte num0 = arr1[0];
		byte num1 = arr1[1];
		byte num2 = arr1[2];
		byte num3 = arr1[3];
		byte num4 = arr1[4];
		//byte num5 = arr1[5];
		System.out.println("数组的第二个元素 = " + num0);//数组的第二个元素 = 0
		System.out.println("数组的第二个元素 = " + num1);
		System.out.println("数组的第二个元素 = " + num2);
		System.out.println("数组的第二个元素 = " + num3);
		System.out.println("数组的第二个元素 = " + num4);
		//System.out.println("数组的第二个元素 = " + num5);
		//获取数组的长度：格式：数组名.length; ---- 没有();
		int length = arr1.length;
		System.out.println("数组的长度 = " + length);//数组的长度 = 5
		//改 ---- 给数组元素重新赋值
		System.out.println("改之前的第一个元素 = " + arr1[0]);//改之前的第一个元素 = 0
		arr1[0] = 100;
		System.out.println("改之后的第一个元素 = " + arr1[0]);//改之后的第一个元素 = 100
	}
}

/**
	数组使用的注意事项：
	数组声明赋值：
	数组类型[] 数组名 = {v1,v2,....};
*/
class ArraysDemo02
{
	public static void main(String[] args){
		byte[] arr1 = {1,2,3};//和使用 byte[] arr1 = new byte[]{1,2,3};一样
		//但前者不能先声明再赋值，后者可以  如下：
		//byte[] arr2;
		//arr2 = {1,2,3};//错误
		byte[] arr3;
		arr3 = new byte[]{1,2,3};//正确
	}
}

/**
	整型默认是0
	浮点型 0.0
	char 0
	boolean false

	注意引用类型：
			默认类型是 null 值
*/
class ArraysDemo03
{
	public static void main(String[] args){
		byte[] arr1 = new byte[5];
		int[] arr2 = new int[5];
		short[] arr3 = new short[5];
		long[] arr4 = new long[5];
		System.out.println(arr1[0]);// 0
		System.out.println(arr2[0]);// 0
		System.out.println(arr3[0]);// 0
		System.out.println(arr4[0]);// 0
		System.out.println("---------------------------");
		float[] arr5 = new float[5];
		double[] arr6 = new double[5];
		System.out.println(arr5[0]);// 0.0
		System.out.println(arr6[0]);// 0.0
		System.out.println("---------------------------");
		char[] arr7 = new char[6];
		System.out.println((int)arr7[0]);// 0  不强转就是什么都没有因为0没有对应的字母
		System.out.println("---------------------------");
		boolean[] arr8 = new boolean[6];
		System.out.println(arr8[0]);// false
		System.out.println("---------------------------");
		String[] arr9 = new String[6];
		System.out.println(arr9[0]);// mull
	}
}

2、数组高级操作：

class ArraysUtil
{
	public static void printArray(int[] arr){
		//遍历数组，取出元素并打印
		//初始化数据 ---- 开始索引0
		//判断条件 ------ 是不是在数组索引范围内
		//改变条件 + 1 ---
		for(int index = 0; index < arr.length; index++){
			System.out.println("数组的第" + (index + 1) + "个元素是：" + arr[index]);
			/*打印结果：
			数组的第1个元素是：3
			......
			......
			数组的第6个元素是：8
			*/
		}
	}
	public static String toString(int[] arr){
		//将数据转成字符串
		//1、创建字符串接收转化的数据
		String str = "[";//[  
		//2、遍历数组，要将数组的每一个元素拼接到str
		for(int i = 0; i < arr.length; i++){
			//添加筛选条件
			if(i == arr.length - 1){
				str = str + arr[i] + "]";
			}else{
				str = str + arr[i] + ",";//[3,  [3,5,  [3,5,9,  [3,5,9,7,  [3,5,9,7,3,  [3,5,9,7,3,8]
			}
		}
		return str;
	}
	//根据给定数组，生成一样的新数组
	public static int[] copy(int[] arr){
		//长度和元素一样
	    //1、创建一个相同长度的数组
		int[] newArr = new int[arr.length];
		//2、对应的索引赋值操作
		for(int i = 0; i < arr.length; i++){
			//将参数数组的元素的值赋给新数组
			newArr[i] = arr[i];
		}
		//3、返回str
		return newArr;
	}
	public static int[] reverse(int[] arr){
		//第一个和最后一个换位
		//第二个和倒数第二个换位
		//直到中间元素
		for(int index = 0; index < arr.length / 2; index++){
			int temp = 0;
			temp = arr[index];
			arr[index] = arr[arr.length - 1 - index];
			arr[arr.length - 1 - index] = temp;
		}
		return arr;
	}
	public static void main(String[] args){
		int[] arr1 = {3,5,9,7,3,8};	
		printArray(arr1);
		String str = toString(arr1);
		System.out.println("str = " + str);

		int[] newArr = copy(arr1);//复制过程 ---- 新生成了内存
		int[] arr2 = arr1;//赋值过程 ---- 指向的内存一样，赋值赋的是地址值
		newArr[0] = 100;
		arr1[1] = 1000;
		System.out.println(toString(arr1));//[3,1000,9,7,3,8]
		System.out.println(toString(newArr));//[100,5,9,7,3,8]
		System.out.println(toString(arr2));//[3,1000,9,7,3,8]
		System.out.println(arr1);//[I@139a55
		System.out.println(newArr);//[I@1db9742  复制的数组虽然结果一样的地址符不同说明指向的不是同一块内存
		System.out.println("-----------------------------");

		System.out.println("反序前：" + toString(arr1));//反序前：[3,1000,9,7,3,8]
		//数组的反序
		reverse(arr1);
		System.out.println("反序后：" + toString(arr1));//反序后：[8,3,7,9,1000,3] 
	}
}

3、二维数组

二维数组 ---- 数组存数组

数组的元素的数据类型可以是基本类型：

byte[] arr1;

引用类型：

String[] arr2;

元素本身就是数组：

byte[][] arr3;

二维数组内的元素是数组：

byte[] arr1;

byte arr2[];

byte[][] arr1;

byte[] arr2[];

byte arr3[][];

class ArraysDemo04
{
	public static void main(String[] args){
		//byte[] arr1[];//合法
		byte[][] arr1;
		//大盒子有三个元素 ----> 嵌套的小盒子容量是2
		//前面的[]存储外围数组长度
		//里面的[]存储内围数组长度
		arr1 = new byte[3][2];
		//取出外围第二个元素（数组）的第一个元素
		int num = arr1[1][0];
		//外围数组长度是2，内围数组还没创建
		//这样可以创建不同长度的内围数组
		byte[][] arr2 = new byte[2][];
		arr2[0] = new byte[3];
		arr2[1] = new byte[2];
		//创建时赋值
		byte[][] arr3 = {{1,2,3}，{1,2}，{1,2,3,4}};
	}
}

转载于:https://my.oschina.net/zhanghongjun289/blog/668637