数组学习

最新推荐文章于 2023-08-07 16:51:04 发布
最新推荐文章于 2023-08-07 16:51:04 发布
阅读量148 收藏 1
点赞数
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc1234z0/article/details/103678713
版权

数组：数组是存储同一种数据类型数据的集合容器。

数组的定义格式：
    数据类型[]  变量名 = new 数据类型[长度];

分析数组：   
     左边： int[] arr    声明了一个int类型的的数组变量，变量名为arr。
        int : 表示该数组容器只能存储int类型的数据。
        [] ： 这是一个数组类型。
        arr ： 变量名.
    
    右边：new int[50]; 创建了一个长度为50的int类型数组对象。
        new ： 创建数组对象的关键字。
        int:  表示该数组对象只能存储int类型数据。
        []： 表示是数组类型。
        50 : 该数组最多能存储50个数据。数组的容量。

        
数组的好处： 对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是： 长度-1.

 

局部变量： 如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。

成员变量： 成员变量就是定义在方法之外，类之内的.

下边举个栗子

class Demo1
{
	public static void main(String[] args) 
	{
		//定义一个数组
		int[] arr = new int[4];
		arr[0] = 10;
		arr[1] = 30;
		arr[2] = 50;
		arr[3] = 90; 
		
		//System.out.println("数组的容量："+ arr.length);	//数组的有一个length 的属性，可以查看数组 的容量。
		//System.out.println("arr[2] = "+ arr[2]);
		
		//查看数组中的所有数据。
		for(int index = 0 ; index<arr.length ; index++){
			System.out.println(arr[index]);
		}

	}
}

 

1、数组的定义

格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[5];

格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

注意：给数组分配空间时，必须指定数组能够存储的元素个数来确定数组大小。创建数组之后不能修改数组的大小。可以使用length 属性获取数组的大小。

遍历数组

2、数组初始化

数组的格式

int[] x = new int[3];

       x[0] = 1;

       x[1] = 2;

另一种定义：该形式可以直接明确数组的长度,以及数组中元素的内容

int[] x = { 1, 2, 3 };

int[] x=new int[]{1,2,3};

初始化方式1：不使用运算符new

int[] arr = { 1, 2, 3, 4, 5 };

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

初始化方式2：     

int[] arr3=new int[3];

arr3[0]=1;

arr3[1]=5;

arr3[2]=6;

 

如果数组初始化中不使用运算符new。需要注意：下列写法是错误的。

int[] arr;

arr={1,2,3,4,5};

此时初始化数组，必须将声明，创建，初始化都放在一条语句中个，分开会产生语法错误。

所以只能如下写：

int[] arr={1,2,3,4,5};

举个例子：

/* 
数组的初始化方式：
	动态初始化:
		数据类型[] 变量名 = new 数据类型[长度];

	静态初始化：	
		数据类型[] 变量名 = {元素1，元素2.....};
如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。

*/
class Demo 
{
	public static void main(String[] args) 
	{	
		//动态初始化
		//int[] arr = new int[10];
	
		//静态初始化
		int[] arr = {10,20,30,40,50};
		for(int index = 0 ; index<arr.length ; index++){
			 System.out.print(arr[index]+",");
		}

	/*
		int[] arr = new int[50];
		Scanner scanner = new Scanner(System.in);
		for(int i  = 0 ; i< arr.length ; i++){
			arr[i] = scanner.nextInt();
		}
		*/
	}
}

3、数组遍历

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       for (int y = 0; y < 3; y++) {

           System.out.println(x[y]);

           // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

       } // 那么这就是数组的第一个常见操作.遍历

    }

数组中有一个属性可以获取到数组中元素的个数,也就是数组的长度. 数组名.length

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       for (int y = 0; y < x.length; y++) {

           System.out.println(x[y]);

           // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

       } // 那么这就是数组的第一个常见操作.遍历

    }

4、数组的常见异常

（1）数组角标越界异常:，注意：数组的角标从0开始。

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       System.out.println(x[3]);

        //java.lang.ArrayIndexOutOfBoundsException

}

 （2）空指针异常:

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       x = null;

       System.out.println(x[1]);

       // java.lang.NullPointerException

    }

举个栗子:

/*
数组中最常见的问题：
	
	1. NullPointerException 空指针异常
	原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。\

	2. ArrayIndexOutOfBoundsException 索引值越界。
	原因：访问了不存在的索引值。
*/
class Demo2
{
	public static void main(String[] args) 
	{
		/*
		int[] arr = new int[2];
		arr = null ;  //null 让该变量不要引用任何的对象。 不要记录任何的内存地址。
		arr[1] = 10;
		System.out.println(arr[1]);
		
		*/
		int[] arr = new int[4];
		arr[0] = 10;
		arr[1] = 30;
		arr[2]  =40;
		arr[3] = 50;
		//System.out.println(arr[4]); //访问索引值为4的内存空间存储的值。
			
		for(int index = 0 ; index<=arr.length ; index++){
			System.out.print(arr[index]+",");
		}
	}
}

5、数组的内存分析

下边为一些具体应用：

案例1：最大值挑选

/*
需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中 的最大元素返回给调用者。

*/
class Demo
{
	public static void main(String[] args) 
	{
		int[] arr = {-12,-14,-5,-26,-4};
		int max = getMax(arr);
		System.out.println("最大值："+ max); 
	}

	public static int  getMax(int[] arr){
		int max = arr[0]; //用于记录最大值
		for(int i = 1 ; i < arr.length ; i++){
			if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
				max = arr[i];
			}
		}
		return max;
	}
}

案例2： 直接排序

/*
需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。


*/
class Demo{
	public static void main(String[] args) 
	{
		int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
		selectSort(arr);
	}

	public static void selectSort(int[] arr){
		
		//把最大值放在首位置。
		for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
			for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
				if(arr[i]>arr[j]){
					//交换位置
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
	}
/*
		//把老二放在第二个位置
		for(int i = 2  ; i< arr.length ; i++){
			if(arr[i]>arr[1]){
				int temp = arr[i];
				arr[i] = arr[1];
				arr[1] = temp;
			}
		}
		//把老三放在第三个位置
		for(int i = 3  ; i< arr.length ; i++){
			if(arr[i]>arr[2]){
				int temp = arr[i];
				arr[i] = arr[2];
				arr[2] = temp;
			}
		}
		//把老四放在第四个位置
		for(int i = 4  ; i< arr.length ; i++){
			if(arr[i]>arr[3]){
				int temp = arr[i];
				arr[i] = arr[3];
				arr[3] = temp;
			}
		}

*/
		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}

	}
}

 案例3：冒泡排序

/*
需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。

冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。

*/

class Demo10 
{
	public static void main(String[] args) 
	{
		int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
 		bubbleSort(arr);
	}

	public static void bubbleSort(int[] arr){
		// 把最大值放在最后一个位置
		for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
			for(int i = 0 ; i<arr.length-1-j  ; i++){  // 找出一个最大值  
				//相邻的元素比较
				if(arr[i]>arr[i+1]){
					int temp  = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}

/*

		//把老二放在倒数第二个位置上。
		for(int i = 0 ;  i <arr.length-1-1 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

		//把老三放在倒数第三个位置上。
		for(int i = 0 ;  i <arr.length-1-2 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

		//把老四放在倒数第四个位置上。
		for(int i = 0 ;  i <arr.length-1-3 ; i++){
			if(arr[i]>arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}	
		}

*/

		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}
		
	}

}

 

 案例4：二分法

/*
需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在
数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。


折半查找法(二分法): 使用前提必需是有序的数组。


*/
class Demo12 
{
	public static void main(String[] args) 
	{
		int[] arr = {12,16,19,23,54};
		//int index = searchEle(arr,23);
		int index = halfSearch(arr,116);
		System.out.println("元素所在的索引值是："+ index);
	}
	
		
	public static int halfSearch(int[] arr, int target){
		//定义三个变量分别记录最大、最小、中间的查找范围索引值
		int max = arr.length-1;
		int min = 0;
		int mid = (max+min)/2;
		while(true){
			if(target>arr[mid]){
				min = mid+1;
			}else if(target<arr[mid]){
				max = mid -1;
			}else{
				//找到了元素
				return mid;
			}

			//没有找到的情况
			if (max<min){
				return -1;
			}

			//重新计算中间索引值
			mid = (min+max)/2;
		}
	
	}

	public static int searchEle(int[] arr, int target){
		for(int i = 0 ; i<arr.length ; i++){
			if(arr[i]==target){
				return i;
			}
		}
		return -1;
	}
}

 案例5：数组翻转

/*
需求： 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。
	
char[] arr = {'a','b','c','d','e'};

*/
class Demo13 
{
	public static void main(String[] args) 
	{
		//System.out.println("Hello World!");
		char[] arr = {'a','b','c','d','e'};
		reverse(arr);

	}

	public static void reverse(char[] arr){
		for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
			char temp = arr[startIndex];
			arr[startIndex] = arr[endIndex];
			arr[endIndex] = temp;
		}

		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}

	}
}

6、二维数组 

二维数组： 二维数组就是数组中的数组。

一根                变量

一盒     20根       一维数组

一条     10包   20根   二维数组


二维数组 的定义格式：
    
    数据类型[][] 变量名 = new 数据类型[长度1][长度2];

    长度1：一条烟有多少盒。

    长度2： 一盒烟有多少根。


二维数组 的初始化方式：
    
    动态初始化:
        
        数据类型[][] 变量名 = new 数据类型[长度1][长度2];


    静态初始化：

        数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

举个栗子：

class Demo15{

	public static void main(String[] args) 
	{	
		//定义了一个二维数组
		int[][] arr = new int[3][4];
		arr[1][1] = 100;
		/*
		System.out.println("二维数组的长度："+ arr.length);  // 3
		System.out.println("二维数组的长度："+ arr[1].length); //
		*/
		
		System.out.println("数组的元素："+ arr[1][1]);

		
	}
}

7、二维数组静态初始化 

/*
静态初始化：

	数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}
*/
class Demo16 
{
	public static void main(String[] args) 
	{
		int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
		//遍历二维数组
		for(int i = 0;  i <arr.length ; i++){
			for(int j = 0 ; j<arr[i].length ; j++){
				System.out.print(arr[i][j]+",");
			}
			//换行
			System.out.println();
		}
	}

	// 定义一个二维数组，然后计算二维数组中偶数元素的总和。
}

8、二维数组动态初始化： 

int [][] a=new int [3][4];
for(int i=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++){
        a[i][j]=++value;
        }
}

9、二维数组常见的操作:

（1）遍历二维数组

（2）对二维数组求和

package cn.itcast.day;
public class Demo1{
    // 定义一个遍历二维数组的功能函数
    public static void printArr2( int [][] a ){
        // 1. 拆开二维数组
        for ( int i = 0 ; i < a.length ; i++ )
        {
            // 2. 拆开一维数组获取数据
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                System.out.print( a[i][j]+" ," );
            }
        }

    }
    // 定义一个函数计算二维数组中的元素的累加和
    public static long getSum( int [][] a ){
        // 0. 定义一个结果变量
        long sum = 0L;
        // 1. 拆开二维数组
        for ( int i = 0 ; i < a.length ; i++ )
        {
            // 2. 拆开一维数组获取数据
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                sum+=a[i][j];
            }
        }
        return sum;
    }
    // 统计二维数组中元素的个数
    public static int getDataCount( int [][] a ){
        // 0. 记录元素个数
        int  count = 0;
        // 1. 拆开二维数组
        for ( int i = 0 ; i < a.length ; i++ )
        {
            // 2. 拆开一维数组获取数据
            for ( int j = 0 ; j < a[i].length ; j++ )
            {
                count++;
            }
        }
        return count;
    }
    public static void main(String[] args)
    {

        int [][] a = new int[][]{ {23,4,5},{2},{4,5,78,56,90} };
        printArr2( a );
        System.out.println();
        System.out.println("累加和是： "+getSum( a ) );
        System.out.println("统计元素个数： "+getDataCount( a ) );
        System.out.println("Hello World!");
    }
}

运行结果

23 ,4 ,5 ,2 ,4 ,5 ,78 ,56 ,90 ,
累加和是： 267
统计元素个数： 9
Hello World!

Process finished with exit code 0

参考自刘意java

 

 

 

 

 

 

 

 

 

 

 

奔跑的小脑斧
关注
专栏目录
数组学习心得
qq_43628810的博客
12-22 2843
最近学习了数组相关的知识。数组，其实就是一组具有相同类型变量的集合。数组包含数组名和数组元素。程序可以通过数组的下标实现对数组元素的访问。当变量数目很多时，再用以前的方法，即定义一个变量用一个变量，就很难解决问题，这时数组就可以很简单的代替多次定义的难题。 一、知识点 1. 一维数组、二维数组的定义 一维数组的定义格式为：数组类型 数组名 ［元素个数］; 。 相应的，二维数组是在...
PHP之数组学习
12-18
在PHP编程语言中，数组是一种特殊的数据结构，用于存储一系列有序的数据。数组可以在单个变量中存储多个值，这些值可以是任何数据类型，包括...通过不断实践和学习，我们可以更好地利用数组功能来解决各种编程问题。
C语言-函数基础
最新发布
少壮不努力，长大写程序
08-07 415
C语言函数是封装操作的代码块，提高代码的模块化和重用性，实现功能的组织和调用。函数具有参数传递、返回值和局部变量，通过函数调用实现代码的结构化和分层设计。
Java复习笔记（六）数组
chenjipayne的博客
05-02 124
数组 一、数组的概念    数组是同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素， 也就是数组一旦定义，那么里边存储的...
使用递归实现二分查找数组元素索引， int[] arr = {1,2,3,4,5,6,7,8,9};
q18390820817的博客
05-08 4582
public class demo16 {public static void main(String[] args) { int[] arr = {1,2,3,4,5,6,7,8,9}; System.out.println(binarysearch(arr,7,arr.length-1,0));}public static int binarysearch(int[] arr,int res...
public static void main(String[] args){}函数诠释
热门推荐
Chen
07-25 1万+
主函数的一般写法如下：　　public static void main(String[] args){…}　　下面分别解释这些关键字的作用：　　（1）public关键字，这个好理解，声明主函数为public就是告诉其他的类可以访问这个函数。　　（2）static关键字，告知编译
public static void main(String args[])什么意思？
weixin_33675507的博客
03-09 938
　　public static void main(String[] args) 　　这绝对不是凭空想出来的，也不是没有道理的死规定，而是java程序执行的需要。 　　jvm在试图运行一个类之前，先检查该类是否包含一个特殊方法。这个方法必须是公有的，以便在任何位置都能访问得到。这个方法必须是static的，因为这个方法不能依赖任何该类的实例即可运行，而非static的方法，在运行之前要先创建该...
C语言-数组学习
weixin_54794458的博客
10-11 3091
C语言 数组学习
Arduino数组学习
wsq_666的博客
11-16 3923
一、四组舵机转动效果一样 #include <Servo.h> Servo base,fArm,rArm,claw;//创建4个电机分别为base,fArm,rArm,claw int data[5]={0,45,90,135,180};//定义一个包含5个数据的整型数组 void setup() { base.attach(11); //base伺服电机连接到引脚11，电机代号b fArm.attach(10); //fArm伺服电机连接到引脚10，电机代号r
c语言数组学习
龙龙的博客
11-21 4546
1.1一维数组 1.1.1 定义一维数组 定义一维数组的一般形式为： 类型符 数组名[常量表达式] 例如定义以下数组： int student[10]; 注意： 数组名的命名规则和变量名相同，遵循标识符命名规则。 在定义数组时，需要指定数组中元素的个数，方括号中的常量表达式用来表示元素的个数，即数组长度。例如，student[10]，表示数组 a[] 有 10 个元素。注意，下标是从 0 开始...
Java使用数组学习心得
m0_68028457的博客
05-02 983
数组的长度初始化后不可变，而String类型初始化后值不可变 提到数组和字符串，就不得不提两者很容易混淆的length和length（）属性，下面这篇文章对比了两者： 初始化数组时 不要既动态初始化又静态初始化，即不要既指定长度又分配初始值 下面是错误示范： int[] x = new int[3]{1,2,3}; 正确写法： int[] x = new int[3]; x[0] = 1; x[1] = 2; x[3] = 3; 或者: int[] x = new ..
C语言数组学习教案.pptx
09-30
"C语言数组学习教案" 本节课件主要讲解C语言中的数组知识点，包括数组的定义、引用、初始化等基本概念和操作。 一、数组的定义 在C语言中，数组是一种构造数据类型，由基本数据类型通过一定的规则组合而成。定义...
动画框数组学习.rar
04-06
本资源“动画框数组学习.rar”显然是一个压缩包，包含了一个易语言（EasyLanguage）的源代码示例，用于教授如何使用动画框数组进行编程。易语言是一款面向初学者的中文编程软件，它的语法简洁明了，适合初学者学习...
matlab 三维 数组学习文件
11-18
在 MATLAB 中，三维数组是一种非常重要的数据结构，尤其在处理多维数据时，例如图像处理、信号处理等领域。本篇文章将深入探讨如何在 MATLAB 中创建和操作三维数组，特别是通过 `reshape` 函数来实现。 首先，理解 ...
VBA数组学习笔记.pdf
10-08
VBA 数组学习笔记 VBA 数组学习笔记是指在 Visual Basic for Applications（VBA）中对数组的学习和应用。数组是 VBA 编程中非常重要的一部分，它可以用来存储和处理大量的数据。 数组的声明 在 VBA 中，数组的...
自定义图书类
风记忆的博客
11-25 1479
在项目中创建Book类，在类中定义3个成员变量，分别表示书名，作者与价格，同时提供构造方法和成员方法来修改成员变量。 package ace; public class Book { private String title; private String author; private double price; public Book(String title,String author,do...
两种设计模式（观察者模式与单例模式）
风记忆的博客
01-30 840
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 一、观察者模式 有时又被称为 发布-订阅<Publish/Subscribe>模式、模型-视图<Model/View>模式、源-收听者<Source/Lis...
将a.txt、b.txt、c.txt中的内容合并成文档d.txt
风记忆的博客
02-05 771
package pack; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.SequenceInputStream; import java.util.ArrayList; import ...
浅谈break、continue、return
风记忆的博客
12-24 394
（1）break break适用范围：只能用于switch或者是循环语句中。 break作用： 1. break用于switch语句的作用是结束一个switch语句。 2. break用于循环语句中的作用是结束当前所在的循环语句。 笔试题目：break目前位于内层的for循环，如何才能让break作用于外层 的for循环。 可以标记解决 标记的命名只要符合标识符的命...
PHP数组学习：定义与创建方法
"PHP之数组学习" 在网页编程中，数据的存取和读写是核心任务，PHP提供了多种数据存储结构，其中数组是尤为重要的一种。数组允许我们存储多个值在一个变量中，方便管理和操作。本篇文章将重点讨论PHP数组的定义、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值