数组相关知识

数组的声明

注意：

1.数组的名称要按照标识符的命名规则

2.一个数组只能保存一种数据类型

3.new 关键字表示在内存中开辟空间来保存数据

第一种声明：

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明数组的第一种方式，该数组可以保存5个int类型的数据
		int [] nums =new int[5];
		//取得数组的长度
		System.out.println(nums.length)；//5
	}
}

第二种声明：

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明数组的第二种方式，该数组可以保存6个int类型的数据
		int [] nums =new int[]{1,2,3,4,5,6};
		//取得数组的长度
		System.out.println(nums.length);//6
	}
}

第三种声明：

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明数组的第三种方式，该数组可以保存7个int类型的数据
		int [] nums ={1,2,3,4,5,6,7};
		//取得数组的长度
		System.out.println(nums.length);//7
	}
}

数组的内存分配结构

通过“数组名【下标】”的方式去访问，

取得数组中的所有元素

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		int [] nums =new int[]{1,2,3,4,5,6,7};
		for (int i=0;i<nums.length ;i++ )
		{
             System.out.print(nums[i]+",");
		}
	}
}

给数组赋值，把下标为偶数的数组扩大100倍

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		int [] nums =new int[]{1,2,3,4,5,6,7};
		for (int i=0;i<nums.length ;i++ )
		{
             if (i%2==0)
             {
				 nums[i]=nums[i]*100;
             }
			 System.out.print(nums[i]+",");
		}
	}
}

使用while循环输出数组的元素

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		int [] nums =new int[]{1,2,3,4,5,6,7};
		for (int i=0;i<nums.length ;i++ )
		{
             if (i%2==0)//赋值
             {
				 nums[i]=nums[i]*100;
             }
		}
		int footer=0;//读取
		while (footer<nums.length)
		{
			System.out.print(nums[footer]+",");
				footer++;
		}
	}
}

二维数组的内存分配结构

二维数组的声明

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		int [] [] arr ={{1,2),{3,4},{5,6}};
	}
}

二维数组的声明

第一种方式

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个二维数组
		double [][] nums ={{1,2},{3,4},{5,6},{7,8}};
		//遍历一个二维数组
		for (int i=0;i<nums.length ;i++ )//只能遍历外层数组
		{
			for (int j=0;j<nums[i].length ;j++ )//遍历内层数组
			{
				System.out.print(nums[i][j]+",");
			}
		}
	}
}

第二种方式

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个二维数组
		double [][] nums =new double[3][2];
		//为数组赋值
		nums[0][0]=1;
	    nums[0][1]=2;
        nums[1][0]=3;
        nums[1][1]=4;
        nums[2][0]=5;
        nums[2][1]=6;
		//遍历一个二维数组
		for (int i=0;i<nums.length ;i++ )//只能遍历外层数组
		{
			for (int j=0;j<nums[i].length ;j++ )//遍历内层数组
			{
				System.out.print(nums[i][j]+",");
			}
		}
	}
}

第三种方式

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个二维数组
		double [][] nums =new double[3][];
		//为数组赋值
		nums[0][0]=1;
	    nums[0][1]=2;
        nums[1][0]=3;
        nums[1][1]=4;
        nums[2][0]=5;
        nums[2][1]=6;
		//遍历一个二维数组
		for (int i=0;i<nums.length ;i++ )//只能遍历外层数组
		{
			for (int j=0;j<nums[i].length ;j++ )//遍历内层数组
			{
				System.out.print(nums[i][j]+",");
			}
		}
	}
}

Exception in thread "main" java.lang.NullPointerException
        at Hello.main(Hello.java:8)

说明我们的程序访问了一个不存在的数组。

只创建了外层数组，内层数组不存在。

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个二维数组
		double [][] nums =new double[3][];
		for (int i=0;i<nums.length ;i++ )
		{
			nums[i]=new double[i+1];
		}
		//为数组赋值
		nums[0][0]=1;
	    nums[1][0]=2;
        nums[1][1]=3;
        nums[2][0]=4;
        nums[2][1]=5;
		nums[2][2]=6;
		//遍历一个二维数组
		for (int i=0;i<nums.length ;i++ )//只能遍历外层数组
		{
			for (int j=0;j<nums[i].length ;j++ )//遍历内层数组
			{
				System.out.println(nums[i][j]+",");
			}
		}
	}
}

第四种方式

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个二维数组
		double [][] nums =new double[][]{{1,2},{3,4},{5,6}};
		//遍历一个二维数组
		for (int i=0;i<nums.length ;i++ )//只能遍历外层数组
		{
			for (int j=0;j<nums[i].length ;j++ )//遍历内层数组
			{
				System.out.println(nums[i][j]+",");
			}
		}
	}
}

加强for循环实现遍历

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		//声明一个数组
		int [] nums ={2,3,4,56,213,90};
		//加强for循环遍历数组
		for (int temp:nums )
		{
			System.out.print(temp+",");	
		}
	}
}

数组越界异常

冒泡排序

比如说一个数组{32，8，64，10，5}实现升序排序（按照从小到大的排序）。

public class Hello//定义一个类
{
	public static void main(String [] args)
	{
		int [] arr ={32,8,64,10,5};
		//对数组进行排序
		for (int i=0;i<arr.length-1 ;i++ )
			//控制比较的轮数的循环
		{
			for (int j=0;j<arr.length-i-1 ;j++ )
				//控制每轮比较的次数
			{
				if (arr[j]>arr[j+1])
					//如果前面一个数大于了后面一个则交换位置
				{
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
                   //输出排序后的数组
				   for (int temp:arr)
		{
					   System.out.print(temp+",");
		}
	}
}