(06)Java学习笔记——数组

最新推荐文章于 2022-12-12 19:25:44 发布
最新推荐文章于 2022-12-12 19:25:44 发布
阅读量412 收藏 1
点赞数
分类专栏： Java 文章标签： java 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexiecm/article/details/54408125
版权

数组：

同一种类型数据的集合，就是一个数据的容器。

多个变量的数据类型要一致。

数组可以存储基本数据类型，也可以存储引用数据类型。


数组初始化：（就是为数组开辟空间，并为每个数组元素赋值）

java中的数组必须先初始化才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值


数组的初始化方式：

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。



数组的格式1（动态初始化）：（需要一个容器，但是不明确容器中的具体数据）

元素类型[ ]   数组名 =  new   元素类型[元素个数或数组长度];     // 用关键字new来建立数组

示例：int [ ] array = new int [ 5 ];      //  数组一建立，必须明确数组长度！


数组的格式2（静态初始化）：（需要一个容器，存储已知的具体数据）

元素类型 [ ]   数组名 = new 元素类型 [ ] {元素1，元素2，元素3，……}

示例：

int [ ] array = new int [ ] {2,4,5,7};   //常规初始化方式

int [ ] array = {2,4,5,7};    //静态初始化方式


**//动给数组中的数据进行角标编号（从0开始），方便操作这些元素。

范例：

class ArrayDemo 
{
	public static void main(String[] args) 
	{
		int [] array=new int[]{5,8,13,64,9};  //定义了一个数组，并在数组中给了元素。
		System.out.println(array[1]);    //打印数组中1角标对应的元素。
	}
}

————————————————————————————————————————


栈内存：存储的都是局部变量。变量所属的作用一旦结束，该变量就自动释放。


堆内存：储存的是数组和对象（其实数组就是对象）凡是new就建立在堆中。

                每个new出来的东西都有首地址值。

                堆内存中的每个变量都有默认初始化值，根据类型的不同而不同。


局部变量：在方法定义中 或者 方法声明上的变量都称为局部变量。


————————————————————————————————————————————

练习01：

定义一个数组，输出该数组的名称和数组元素值
给数组元素赋值，再次输出该数组的名称和数组元素值。

/*
定义一个数组，输出该数组的名称和数组元素值
给数组元素赋值，再次输出该数组的名称和数组元素值。
*/

class  ArrayTest_01
{
	public static void main(String[] args) 
	{
		int [] array = new int[3];
		
		System.out.println(array);

		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);

		System.out.println("----------------------");

		array[0] = 30;
		array[1] = 60;
		array[2] = 90;

		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);

	}
}


练习02：

定义一个数组，给数组元素赋值，输出数组名称和元素

定义第二个数组，给数组元素赋值，输出数组名称和元素

定义第三个数组，把第一个数组的地址值赋值给它（注意类型一致），通过第三个数组的名称去吧元素重新赋值，再一次输出第一个数组名称和元素。


栈内存的两个引用指向同一个堆空间


class ArrayTest_02 
{
	public static void main(String[] args) 
	{
		int [] array1 = new int [3];

		array1[0] = 33;
		array1[1] = 55;
		array1[2] = 88;

		System.out.println(array1);
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);

		System.out.println("--------------------------");

		int [] array2 = new int [4];

		array2[0] = 13;
		array2[1] = 21;
		array2[2] = 89;
		array2[3] = 19;

		System.out.println(array2);
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		System.out.println(array2[3]);

		System.out.println("---------------------------");

		int [] array3 = array1;	//将array1数组的地址给了array3，array3依据地址指向堆内存中的array1内存空间

		array3[0] = 6;
//		array3[1] = 8;
		array3[2] = 5;

		System.out.println(array1);
		System.out.println(array1[0]);	//因为array1的地址给了array3,array3的重新赋值改变了array1中的元素。
		System.out.println(array1[1]);
		System.out.println(array1[2]);
	
	}
}


————————————————————————————————————————————————


数组常见的操作：

对数组的操作动作就是“存”和“取”。实际上就是对角标的操作。


1/数组的遍历

**数组长度的固定语句： 数组名.length 例如：array.length

class ArrayTest01   
{  
    public static void main(String[] args)   
    {  
        int[] array=new int[]{23,4,12,55,29};//定义一个数组，及初始化数组的元素
        for (int x=0;x<array.length ;x++ )// 用数组的长度语句控制循环次数。array.length
  
        {  
            System.out.println("array["+x+"]="+array[x]+";");//用循环语句遍历数组中的0开始的全部角标，并把相对应的值打印出来 

        }  
        System.out.println("length:"+array.length); //统计数组并打印出数组的长度值。
    }  
}


遍历数组的方法：

两个明确：

1 / 返回值类型 ：void

2/ 参数列表：int [ ] array 


数组的一个属性，数组长度 ：数组名 . length


class ArrayTest_03 
{
	public static void main(String[] args) 
	{
		int [] array = new int[] { 3,6,88,33,12,5,66,47,29};	//声明一个数组，并静态初始化赋值
		
		printArray(array);	//调用打印数组的方法
			
	}

	public static void printArray(int[] array)	//创建一个遍历打印数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			System.out.println(array[x]);
		}
	}
}


2/数组取最值
思路：

1/1需要进行比较，并定义变量来记录每次比较厚较大的值。

2/对数组中的值遍历取出和变量中的值进行比较，取出较大值。

class ArrayTest02 
{
	public static void main(String[] args) 
	{
		int [] array=new int[]{34,55,22,7,98,12,67};  //定义一个数组并初始化了元素
		int getmax=max(array);     //调用名为max的方法，将最大值赋给getmax
		System.out.print(getmax);   //打印数组中的最大值
	}

	public static int max(int[] array)   //定义了一个方法，用来遍历比较数组中的元素，取出最大值
	{
		int max=0;
			
		for (int x=0;x<array.length ;x++ )
		{
			if (array[x]>max)
			{
				max=array[x];
			}
		}
		return max;	
	}
	
}


3/ 数组元素逆序

/*
数组的逆序

分析：
把数组角标0的元素和array.length-1的数据交换
把数组交表1的元素和array.length-2的数据交换
。。。。。
只要做到array.length/2的位置


*/

class  ArrayTest_05
{
	public static void main(String[] args) 
	{
		int [] array = new int[] {2,3,4,5,6,7,8,9,10,11,12};

		printArray(array);	//调用打印方法，打印逆序前的数组

		System.out.println();

		reverce(array); //调用逆序方法

		printArray(array);	//调用打印方法，打印逆序后的数组

//		System.out.println("["+array+"]");


	}

	public static void reverce(int[] array)	//定义一个位置交换的方法
	{
		for (int x=0;x<=array.length/2 ;x++ )
		{
			int temp = array[x];
			array[x] = array[array.length-1-x];
			array[array.length-1-x] = temp;
		}
	}

	public static void printArray(int[] array)	//定义一个遍历打印数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			System.out.print(array[x]+",");
		}

		return ;
	}

}

4 / 数组查表法

根据键盘录入索引，查找对应星期

/*
数组查表法
根据键盘输入索引，查找对应星期
*/

import java.util.Scanner;

class  ArrayTest_06
{
	public static void main(String[] args) 
	{
		String [] weekArray = new String[] {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

		Scanner sc = new Scanner(System.in);

		System.out.println("输入数据");
		int x = sc.nextInt();

		System.out.println("查找的是: "+weekArray[x]);	//依据输入数值，查找数组中对应角标的元素并输出
		
	}
}


5 / 查找数组元素对应角标


/*
查找数组元素对应的角标
*/

class  ArrayTest_07
{
	public static void main(String[] args) 
	{
		int [] array = new int[] {4,65,23,77,1,5,88,13};

		int index = getIndex(array,77);

		System.out.println(index);

	}

	public static int getIndex(int[] array,int value)	//定义一个方法遍历数组并与查询值进行比较。
	{
		for (int x =0;x<array.length ;x++ )
		{
			if (array[x]==value)
			{
				return x;
			}
		}
		return -1;
	}
}





4/ 数组的排序

A / 数组的冒泡排序




范例：

package cn.itcsat_01;

/*
 * 数组的的冒泡排序
 */
public class ArrayDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };
		System.out.println("排序前：");
		printArray(arr);
		
		System.out.println("冒泡排序后：");
		bublleSort(arr);

/*		// 第一次比较
		for (int x = 0; x < arr.length-1-0; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第一次比较：");	//结果：[24, 69, 57, 13, 80]
		printArray(arr);
		
		// 第二次比较
		//arr.length-1  是为了防止越界
		//arr.length -1 -1 是为了减少比较的次数
		for (int x = 0; x < arr.length-1-1; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第二次比较：");	//结果：[24, 57, 13, 69, 80]
		printArray(arr);
		
		// 第三次比较
		for (int x = 0; x < arr.length-1-2; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第三次比较：");	//结果：[24, 13, 57, 69, 80]
		printArray(arr);
		
		// 第四次比较
		for (int x = 0; x < arr.length-1-3; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第四次比较：");	//结果：[13, 24, 57, 69, 80]
		printArray(arr);
		
		System.out.println("-----------------------------------");*/
/*		
		//上面的代码可以用循环改进
		for(int y=0;y<arr.length-1;y++){
			for (int x = 0; x < arr.length-1-y; x++) {
				if (arr[x] > arr[x + 1]) {
					int temp = arr[x];
					arr[x] = arr[x + 1];
					arr[x + 1] = temp;
				}
			}
		}
		System.out.println("冒泡排序结果：");
		printArray(arr);
	*/
	}

	// 遍历功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个数组冒泡排序的方法：
	public static void bublleSort(int[] arr){
		for(int y=0;y<arr.length-1;y++){
			for (int x = 0; x < arr.length-1-y; x++) {
				if (arr[x] > arr[x + 1]) {
					int temp = arr[x];
					arr[x] = arr[x + 1];
					arr[x + 1] = temp;
				}
			}
		}
		printArray(arr);
	}
}


B / 数组的选择排序

思想：

分别用数组内的元素进行遍历。

用第三个临时变量来换位，将小的元素移动到前面。


范例：

package cn.itcsat_02;

/*
 * 数组的选择排序
 */
public class ArrayDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };
		System.out.println("排序前：");
		printArray(arr);
		
		System.out.println("选择排序后：");
		selectSort(arr);

/*		// 第一次排序
		int x = 0;
		for (int y = 1; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第一次排序后：");
		printArray(arr);
		
		// 第二次排序
		//经过第一次排序后，0角标元素不再参与比较
		x = 0+1;
		for (int y = 1+1; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第二次排序后：");
		printArray(arr);
		
		// 第三次排序
		//经过第二次排序后，1角标元素不再参与比较
		x = 0+2;
		for (int y = 1+2; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第三次排序后：");
		printArray(arr);
		
		// 第四次排序
		//经过第三次排序后，2角标元素不再参与比较
		x = 0+3;
		for (int y = 1+3; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第四次排序后：");
		printArray(arr);
		
		System.out.println("----------------------------");
		
		
		//上面的过程可以简化成下列代码：
		for (int z=0;z<arr.length-1;z++){
			x = 0+z;
			for (int y = 1+z; y < arr.length; y++) {
				if (arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		System.out.println("选择排序后：");
		printArray(arr);
*/
	}

	// 遍历数组的功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个选择排序的方法
	public static void selectSort(int[] arr){
		for (int z=0;z<arr.length-1;z++){
			int x = 0+z;
			for (int y = 1+z; y < arr.length; y++) {
				if (arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		printArray(arr);
	}
}
练习01：把字符串中的字符进行排序

举例：“dacgebf"

结果：”abcdefg"

package cn.itcast_03;
/*
 * 把字符串中的字符进行排序
 * 思路：
 * A/ 把字符串转换成字符数组
 * B/ 通过对字符数组的排序后，得出符合顺序的字符数组
 * C/ 将符合顺序的字符数组转成字符串
 */
public class ArrayTest_01 {
	public static void main(String[] args) {
		//定义一个字符串
		String s = "dacgebf";
		
		//把字符串转换成字符数组
		char[] chs =s.toCharArray();
		printArray(chs);
		bulleSort(chs);
		printArray(chs);	//打印输出排序后的字符数组
		
		//将排序后的字符数组转成字符串
		String s1 = String.valueOf(chs);
		
		System.out.println(s1);
	
	}
	
	//定义一个遍历数组并打印数组的功能
	public static void printArray(char[] chs){
		System.out.print("[");
		for(int x=0;x<chs.length;x++){
			if(x==chs.length-1){
				System.out.print(chs[x]);
			}
			else{
				System.out.print(chs[x]+", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个数组排序的功能
	public static void bulleSort(char[] chs){
		for(int x=0;x<chs.length-1;x++){
			for(int y=0;y<chs.length-1-x;y++){
				if(chs[y]>chs[y+1]){
					char temp=chs[y];
					chs[y]=chs[y+1];
					chs[y+1]=temp;
				}
			}
		}
	}
}


5/数组查找 （查找数组中某个元素对应的角标）

思路：用遍历方式查找。

范例：

class ArrayTest05 
{
	public static void main(String[] args) 
	{
		int[] array=new int[] {45,33,7,89,32,14,55};
		int index=getIndex(array,14);  //给出需要寻找的元素
		System.out.print("index="+index);  //打印出所寻找元素的对应角标
	}

	public static int getIndex(int[] array,int element)  //定义一个方法，用于寻找某元素的角标
	{
		for (int x=0;x<array.length ;x++ )
		{
			if (array[x]==element)
			{
				return x;
			}
		}
		return -1;
	}
}

6/数组的二分查找（折半查找）

前提：数组元素是有序的


范例：

package cn.itcast_04;

/*
 * 数组的折半查找
 * 思路：
 * A/定义最大索引，最小索引
 * B/ 计算中间索引
 * C/ 拿中间索引的值和要查找的值进行比较
 * 相等：就返回当前的中间索引
 * 不相等：小：左边找
 * 		大：右边找
 * D/ 重新计算出中间索引
 * 大：左边找   max = mid-1;
 * 小：右边找   min = mid+1;
 * E/ 回到B
 * 
 */
public class ArrayDemo {
	public static void main(String[] args) {

		// 定义一个数组
		int[] arr = { 11, 22, 33, 44, 55, 66, 77 };

		// 调用方法
		int index = getIndex(arr, 33);
		System.out.println(index);
	}

	// 写方法实现：
	/*
	 * 两个明确： 1.返回值类型 2。参数列表 int[] arr, int value
	 */
	public static int getIndex(int[] arr,int value){
		//定义最大索引，最小索引
		int max = arr.length-1;
		int min = 0;
		
		//计算中间索引
		int mid = (max+min)/2;

		//拿中间索引的值和要查找的值进行比较
		while (arr[mid]!=value){
			if(arr[mid]>value){
				max = mid-1;
			}
			else if(arr[mid]<value){
				min = mid+1;
			}
			
			//加入判断
			if(min>max){
				return -1;
			}
			mid =(max+min)/2;
		}
		return mid;
	}
}






7/进制转换

8/查表法

————————————————————————————————————


二维数组（数组中的数组）


格式1：（动态初始化）

数据类型 [ ] [ ]  数组名 = new 数据类型 [m ] [n ]

m表示这个二维数组有多少个一维数组

n表示每个一维数组的元素个数


int[ ] [ ] array=new int [3] [2];

1/定义了一个名为array的二维数组

2/二维数组中有3个一位数组

3/每个一维数组中有2个元素


		int [][] array=new int[3][2];  //定义一个二维数组。该数组中有3个一维数组，每个一维数组中有2个元素。

		System.out.println(array);	//直接打印二维数组
		System.out.println(array[0]);	//直接打印二维数组中的角标0的一维数组。
		System.out.println(array[0][0]);	//直接打印二维数组中的角标0的一维数组中的角标为0的元素。


二维数组的内存图解



		int[][] array=new int[3][2];

		System.out.println(array.length);	//打印二维数组的长度，其实就是一维数组的个数
		System.out.println(array[1].length);	//打印二维数组中角标为1的一维数组的长度。


格式2:（动态初始化）

数据类型 [ ] [ ]  数组名 = new  数据类型 [ m ] [ ] 

m表示这个二维数组有多少个一维数组

没有给出一维数组的元素个数，可以动态给出。


int [ ] [ ]  array = new int [ 3 ] [ ]

array[0]=new int [2 ];

array[1]=new int [1];

array[2]=new int [3];



格式3：

数据类型[ ] [ ]  数组名 = { {元素1，元素2，....}，{元素1，元素2，元素3，...}，{元素1，元素2，....}}

int[ ] [ ] array={{3,1,7},{4,6.2.9},{4,3,7}};


练习01：二维数组的遍历

用forfor循环嵌套方法遍历二维数组，

外循环控制的是二维数组的长度（一维数组的个数）

内循环控制的是一维数组的长度

/*
二维数组的遍历
分析：
用forfor循环的思想
*/

class ArrayTest02_01 
{
	public static void main(String[] args) 
	{
		int [] [] array ={{2,6,11,54},{55,3,71,33,87},{23,17}};
		
		ergodic(array);	//调用遍历方法
	}

	public static void ergodic(int [][] array)	//定义一个用forfor循环遍历二维数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			for (int y=0;y<array[x].length ;y++ )
			{
				System.out.print(array[x][y]+", ");
			}
			System.out.println();
		}
	}
}


练习02：公司年销售额求和

/*
公司年销售额求和
第一季度：22，66，44
第二季度：77，33，88
第三季度：25，45，65
第四季度：11，66，99

分析：
定义二维数组int [季度数] [每季度销售额]
定义一个统计方法
forfor循环嵌套遍历数组
将遍历出来的元素统计输出
 
*/

class  ArrayTest02_02
{
	public static void main(String[] args) 
	{
		int [][] array = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

		int result = arraySum(array);

		System.out.println("年销售额是"+result);
		
	}

	public static int arraySum(int [][] array)
	{
		int sum = 0;
		for (int x=0;x<array.length ;x++ )
		{
			for (int y=0;y<array[x].length ;y++ )
			{
				sum = sum+array[x][y];
			}
		}

		return sum;
	}
}

练习03：打印杨辉三角形

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

分析：

任何一行的第一列和最后一列都是1

从第三行开始，每一个数据都是它上一行的前一列和它上一行的本列之和。最后一列除外。


练习04：数据转换成数组进行操作


如何把数据转换成数组？：

a/定义一个数据：

int number = 123456;

b/定义一个数组，将数组长度定义8（不超过8位的数据）

c/获取每一个数据，然后赋值进数组

参考《流程控制——水仙花数》模运算的方法取出每一位数字。





xiexiecm
关注
专栏目录
javascript ES5中 foreach()遍历方法
weixin_44638167的博客
09-28 5982
forcach() array.forEach(function(currentValue, index, arr)) currentValue：数组当前项的值 index：数组当前项的索引 (可选) arr：数组对象本身 filter() 方法创建一个新的数组， 新数组中的元素是通过检查指定数组中符合条件的所有元素,主要用于筛选数组 注意它直接返回一个新数组 代码: <script> var arr=[50,86,12,10,0,38]; var newa
java数组的题目_Java数组实例练习题整理
weixin_29117669的博客
02-12 998
初级1.定义一个函数，获取某个数组中的最小值package practise;public class GetMin {public static void getMin(int[]num){int min = num[0];for(int i=0;imin=(num[i]}System.*out*.print(min);}public static void main(String[] args...
用int[] arr=new int[]创建数组
热门推荐
aiaidebaba的博客
08-21 1万+
Java SE 数组的建立 package javaDemo.java; import java.util.Scanner; public class Zuoye4 { public static void main(String[] args) { int chengji; double sum=0; int[] arr=new int[6];//创建数组 int i ,b...
java学习--基础知识第四天--Random、数组
weixin_30849403的博客
03-24 134
今日内容介绍 u Random u 数组 第1章 Random 1.1 产生整数随机数 1.1.1 Random的使用步骤 我们想产生1~100(包含1和100)的随机数该怎么办呢? 我们不需要自己去写算法,因为Java已经为我们提供好了产生随机数的类---Random: 作用： – 用于产生一个随机数 • 使用步骤(和Scanner类似) – 导包 • import ja...
假设有一个长度为5的数组，int[] array = new int[] {1,3,-1,5,-2}；
qq_46337964的博客
03-26 4720
假设有一个长度为5的数组，如图所示： int[] array = new int[] {1,3,-1,5,-2}; 现在要创建一个新数组new Array[]，要求新数组中的元素是对原数组中的元素升序排列后所得。编程输出新数组中的元素，输出结果如下所示。 代码如下： /** * Author：Xu Zheng Wei * E-mail：2518298846@qq.com * 程序功能：利用冒泡排序把自己定义的一组数据按照从小到大的顺序输出； */ package com.lianxit
Java学习笔记——数组
大奖状的博客
11-28 276
java
【Java学习笔记——数组】
zeng_q_yan的博客
11-24 443
Java学习笔记——数组2021.11.24数组其他知识补充 数组 常见概念： 数组名 下标（或索引）从0开始 元素 数组的长度 数组是有序排列的。 数组属于引用数据类型的变量。数组的元素可以是任何数据类型，既可以是基本数据类型，也可以是4引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。 数组的长度一旦确定，不能修改。 数组的分类 按照维数：一维数组、二维数组… 按照数组元素类型：基本数据类型的数组、引用数据类型的数组 一维数组的使用
java学习笔记——数组
Small__明的博客
11-17 365
java学习笔记——数组 文章目录java学习笔记——数组一、数组定义数组默认值内存分配静态初始化数组遍历数组 一、数组 定义数组 int [] arr = new int[3]; // int是数据类型， []代表数组， arr是数组名, new是为数组申请空间。 默认值 整数：0 浮点：0.0 布尔：false 字符：空字符 引用数据类型：null 内存分配 多个数组指向同一个内存，arr和arr2指向的是同一个地址。 静态初始化数组 int [] arr = {1,2,3}; 遍历数组 for
JAVA学习笔记——数组
weixin_45303372的博客
06-01 189
2021.5.25 1.数组的特点： 1.数组是有序的； 2.数组属于引用数据类型的变量； 3.数组在内存中是连续的； 4.数组的长度一旦确定不能修改。 2.数组的分类： 1.按照维数 2.按照数组元素的类型：基本数据类型数组，引用数据类型数组。 3.一维数组的使用 1.一维数组的声明和初始化 2.如何调用指定位置元素 3.获取数组长度 4.如何遍历数组 5.数组元素的默认初始化值 6.数组的内存解析 1.一维数组的声明和初始化 int[] ids;//声明 //静态初始化:
我的学习笔记——数组
最新发布
YI178的博客
12-12 274
关于数组的简单介绍和使用方法。
javascript从入门到跑路—–小文的js学习笔记（10）——数组（一维数组、二维数组以及三维数组）和冒泡排序
01-08
javascript从入门到跑路—–小文的js学习笔记（1）———script、alert、document。write() 和 console.log 标签 … … javascript从入门到跑路—–小文的js学习笔记目录 ** 含义： 使用单独的变量名来存储一系列的...
Java笔记06——数组的定义和使用
m0_61608447的博客
04-10 4313
包含 Java数组相关的知识点 + 解析 + 内存运转的简单了解 + 练习题
学习笔记（JAVA）——数组
qq_50233116的博客
05-15 474
数组
【笔记】Java学习——数组
AI_LYF1987的博客
08-11 204
Java数组学习
(12)Java学习笔记——面向对象06——接口 / 引用类型作为形参和返回值类型
xiexiecm的博客
01-17 940
接口 关键字interface 当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类使用另一种形式定义和表示，就是接口 interface 定义接口使用的关键字不是class，是interface 接口内常见的定义的成员：（而且这些成员都有固定的修饰符） 接口中的成员都是公共的权限。 1/抽象方法 public abstract 2/全局常量 public
(20)Java学习笔记——常用对象API /Object类
xiexiecm的博客
01-24 926
String 类 特点： 字符串对象一旦被初始化就不会被改变 字符串存储在字符串常量池中，如果没有，见建立。如果池中有相同的字符串，直接拿来用。 两种创建方式的比较： String s = "abc"; //创建一个字符串对象在常量池中。 String s1 = new String ("abc");  //创建两个对象，一个是new ,一个是字符串对象，在内存中。 以上两种
(24)Java学习笔记——常用对象API / Arrays(数组工具类）
xiexiecm的博客
02-06 743
Arrays类 针对任意数组进行操作的工具类 提供了排序，查找功能 成员方法： public static String toSting(int[ ] a)   //把数组转成字符串 public static void sort(int[ ] a)    //数组的排序 public static int binarySeach(int[ ] a, int key)    /
(04)Java学习笔记——程序流程控制（控制语句）
xiexiecm的博客
01-15 607
结构： 1.顺序结构 2.判断结构 3.选择结构 4.循环结构 ———————————————— 判断结构：if （必须要明确自己的控制范围{}） 1. 第一种格式： if(条件表达式） {     执行语句； } 2.第二种格式：(某些情况下，三元运算符就是if...else的简化格式） （简写格式什么时候用？当if...else运算后，有一个具体的结果时，可以简化写成三元运算符） if
(41)Java学习笔记——IO流技术 / 递归
xiexiecm的博客
02-16 490
递归 方法定义中调用方法本身的现象 递归注意事项： 要有出口，否则就是死递归 次数不能太多，否则就内存溢出 构造方法不能递归使用 区别： 方法的嵌套调用，例子： Math.max(Math.max(a,b),c); 递归，例子： publi void show(){       show(); } 递归解决问题的方法：分解法   合并法 范例：求阶乘，用代码实现
Java入门笔记：数组详解与内存理解
首先，我们来看第三章——数组的遍历与定义。 1. 定义数组： Java提供了三种方式来定义数组： - 第一种是动态创建，使用`int arr = new int[3];`，这种方式创建的数组没有预设长度，可以根据实际需要动态添加或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值