JAVA学习第四课(数组)



数组：
同一类型数据的集合，即一种容器。
定义方式：

int[] atrr = new int[5];//int 型数组 数组名arr ，new动态开辟  int[5]，数组大小为5,只能存放5个元素，

下标0-4

 

数组定义后在内存中的基本分布：
内存的划分：
1.寄存器 -> CPU
2.本地方法区,与所在系统相关
3.方法区
4.栈内存：        存储的都是局部变量，且变量所属的作用域一旦结束，当前变量就会自动释放，所以        栈内存更新速度很快，因为栈内变量的生命周期都很短（结束就释放）。 例如：局部代码块，其限定局部变量的生命周期，在某些大程序里，main函数不结束

其中的变量就不释放，所以引用局部代码块。

示例代码：

 

  1. import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;
  3. public class Main
  4. {
  5.     public static void main(String[] args)
  6.     {
  7.         int[] arr = new int[6];
  9.         System.out.println(arr[1]);
  12.         {//局部代码块，在{}中age有效，{}执行玩age自动释放
  13.             int age = 3;
  14.             System.out.println(age);
  15.         }
  17.         System.out.println();
  18.     }
  20. }
import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

public class Main 
{
	public static void main(String[] args)
	{
		int[] arr = new int[6];

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

		{//局部代码块，在{}中age有效，{}执行玩age自动释放
			int age = 3;
			System.out.println(age);
		}

		System.out.println();
	}

}

5.堆内存：、

 

堆中存储的是对象（数组），凡是new建立的都在堆中，堆不会随时释放，堆中存储实体，实体中装载数据，数据中一个损坏，其他的数据依然可以用。而栈一个数据损坏，其他的都不使用
特点： 1.堆中每一个实体都有首地址值。

2.堆内存中每一个局部变量都有默认的初始化值，根据类型的不同，初始化值也不同，例如：int型是0，float 是0.0f\0.0，boolean 是false，char 比较特殊 ‘\u0000′，\u  转义，unicode

3.释放方式：垃圾回收机制

如图：                                                     x = y；

null：
当不想使用arr实体时，arr是数组，若想让arr不做任何实体指向，arr = null,但是堆不会释放arr的地址，

将其视作垃圾。堆里面的垃圾是在不定时自动回收垃圾,故java在内存管理方面优于C++。

 

  1. import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;
  4. public class Main
  5. {
  6.     public static void main(String[] args)
  7.     {
  8.         int[] arr = new int[]{1,1,1,1,1,1};
  10.         System.out.println(arr[1]);
  12.         arr = null;//当引用型变量没有任何实体指向时，还引用该实体，就会引发异常
  14.         System.out.println(arr[2]);
  16.     }
  17. }
import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

public class Main 
{
	public static void main(String[] args)
	{
		int[] arr = new int[]{1,1,1,1,1,1};

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

		arr = null;//当引用型变量没有任何实体指向时，还引用该实体，就会引发异常

		System.out.println(arr[2]);

	}
}

数组使用小练习：

 


 

  1. import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;
  4. public class Main
  5. {
  6.     public static void main(String[] args)
  7.     {
  8.         int[] arr = new int[5];
  9.         int [] b = new int[5];
  10.         arr[0] = 5;
  11.         b[0] = 6;
  12.         b[3] = 15;
  14.         System.out.println(“arr[0] = “+arr[0]);
  15.         System.out.println(“arr[3] = “+arr[3]);
  17.         arr = b;//更改arr的指向
  19.         System.out.println(“arr[0] = “+arr[0]);
  20.         System.out.println(“arr[3] = “+arr[3]);
  21.         System.out.println(“b[3] = “+b[3]);
  22.         System.out.println(“b[0] = “+b[0]);
  24.         b = null;//b无指向
  26.         System.out.println(“arr[0] = “+arr[0]);
  27.         System.out.println(“arr[3] = “+arr[3]);
  28.         //System.out.println(“b[3] = “+b[3]);以视为垃圾
  29.         //System.out.println(“b[0] = “+b[0]);
  30.     }
  31. }
import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

public class Main 
{
	public static void main(String[] args)
	{
		int[] arr = new int[5];
		int [] b = new int[5];
		arr[0] = 5;
		b[0] = 6;
		b[3] = 15;

		System.out.println("arr[0] = "+arr[0]);
		System.out.println("arr[3] = "+arr[3]);

		arr = b;//更改arr的指向

		System.out.println("arr[0] = "+arr[0]);
		System.out.println("arr[3] = "+arr[3]);
		System.out.println("b[3] = "+b[3]);
		System.out.println("b[0] = "+b[0]);

		b = null;//b无指向

		System.out.println("arr[0] = "+arr[0]);
		System.out.println("arr[3] = "+arr[3]);
		//System.out.println("b[3] = "+b[3]);以视为垃圾
		//System.out.println("b[0] = "+b[0]);
	}
}

 

 

使用数组容易遇见的小问题

 

  1. import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;
  4. public class Main
  5. {
  6.     public static void main(String[] args)
  7.     {
  8.         int[] arr = new int[5];
  9.         int [] b = new int[5];
  11.         System.out.println(arr);//[I@15db9742，15db9742是arr存储的哈希值，[->数组，I -> int型
  13.         //所以，在我们不知道，当前实体是什么类型的实体时，就可以直接当前该实体的名字
  15.     }
  16. }
import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

public class Main 
{
	public static void main(String[] args)
	{
		int[] arr = new int[5];
		int [] b = new int[5];

		System.out.println(arr);//[I@15db9742，15db9742是arr存储的哈希值，[->数组，I -> int型

		//所以，在我们不知道，当前实体是什么类型的实体时，就可以直接当前该实体的名字

	}
}

 

数组的另一种定义方式：

格式2：已知数组元素，只是需要一个容器来存储

 

 

  1. public class Main
  2. {
  3.     public static void main(String[] args)
  4.     {
  5.         int[] arr = new int[5];
  7.     //  int[] b = new int[]{1,2,3,4,5};同下
  9.         int b[] = {1,2,1,3,4,7,8,9,4,1,2,5,6,7,4,5,1,2,3,6};//同上
  10.         int len = b.length;
  11.         for(int i = 0;i<len;i++)
  12.         {
  13.             System.out.println(“b["+i+"]= “+b[i]);
  14.         }
  15.     }
  16. }
public class Main 
{
	public static void main(String[] args)
	{
		int[] arr = new int[5];

	//	int[] b = new int[]{1,2,3,4,5};同下

		int b[] = {1,2,1,3,4,7,8,9,4,1,2,5,6,7,4,5,1,2,3,6};//同上
		int len = b.length;
		for(int i = 0;i<len;i++)
		{
			System.out.println("b["+i+"]= "+b[i]);
		}
	}
}

数组练习：

进制转换

 

  1. import java.awt.print.Printable;
  2. import java.util.Arrays;
  3. import java.util.Scanner;
  5. import javax.swing.text.DefaultEditorKit.InsertBreakAction;
  7. import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;
  9. /* 需求：
  10. * 获取一个整数的X进制的表现形式
  11. * */
  12. public class Main
  13. {
  14.     public static void main(String[] args)
  15.     {
  16.         Scanner cin = new Scanner(System.in);
  17.         int num = cin.nextInt();
  19.         int ary[] = new int[8];
  20.         getx(num,ary,15,4);//16进制
  21.         System.out.println(“16进制表现形式如下：”);
  22.         print(ary);
  24.         int bry[] = new int[12];
  25.         int num1 = cin.nextInt();
  26.         getx(num1,bry,7,3);//8进制
  27.         System.out.println(“8进制表现形式如下：”);
  28.         print8(bry);
  31.         System.out.println(“6的2进制表现形式如下：”);
  32.         System.out.println(Integer.toBinaryString(6));
  33.         System.out.println(“-6的2进制表现形式如下：”);
  34.         System.out.println(Integer.toBinaryString(-6));
  36.         cin.close();
  37.     }
  38.     public static void print(int[] ary)
  39.     {
  40.         int i;
  41.         for(i = 7;i>=0;i–)
  42.         {
  43.             if(ary[i]!=0)
  44.                 break;
  45.         }
  46.         for(int j = i;j>=0;j–)
  47.         {
  48.             if(ary[j]>9)
  49.             switch (ary[j])
  50.             {
  51.             case 10:System.out.print(“A”);
  52.                 break;
  53.             case 11:System.out.print(“B”);
  54.             break;
  55.             case 12:System.out.print(“C”);
  56.             break;
  57.             case 13:System.out.print(“D”);
  58.             break;
  59.             case 14:System.out.print(“E”);
  60.             break;
  61.             case 15:System.out.print(“F”);
  62.             break;
  63.             default:
  64.                 break;
  65.             }
  66.             else {
  67.                 System.out.print(ary[j]);;
  68.             }
  70.         }
  71.         System.out.println();
  72.     }
  73.     public static void print8(int bry[])
  74.     {
  75.         int i;
  76.         for(i = 10;i>=0;i–)
  77.         {
  78.             if(bry[i]!=0)
  79.                 break;
  80.         }
  81.         for(int j = i;j>=0;j–)
  82.         {
  83.             System.out.print(bry[j]);
  84.         }
  85.         System.out.println();
  86.     }
  87.      public static void getx(int num,int ary[],int mod,int wz)
  88.     {
  89.         int l = 0;
  91.         for(int i = 0;i<8;i++)
  92.         {
  93.             int t = num & mod;//16进制的最大值
  94.             ary[l++] = t;
  95.             num = num >>> wz;//4个二进制位表示一个16进制位
  96.         }
  97.     }
  98. }
import java.awt.print.Printable;
import java.util.Arrays;
import java.util.Scanner;

import javax.swing.text.DefaultEditorKit.InsertBreakAction;

import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

/* 需求：
 * 获取一个整数的X进制的表现形式
 * */
public class Main 
{
	public static void main(String[] args)
	{
		Scanner cin = new Scanner(System.in);
		int num = cin.nextInt();

		int ary[] = new int[8];
		getx(num,ary,15,4);//16进制
		System.out.println("16进制表现形式如下：");
		print(ary);

		int bry[] = new int[12];
		int num1 = cin.nextInt();
		getx(num1,bry,7,3);//8进制
		System.out.println("8进制表现形式如下：");
		print8(bry);

		System.out.println("6的2进制表现形式如下：");
		System.out.println(Integer.toBinaryString(6));
		System.out.println("-6的2进制表现形式如下：");
		System.out.println(Integer.toBinaryString(-6));

		cin.close();
	}
	public static void print(int[] ary)
	{
		int i;
		for(i = 7;i>=0;i--)
		{
			if(ary[i]!=0)
				break;
		}
		for(int j = i;j>=0;j--)
		{
			if(ary[j]>9)
			switch (ary[j]) 
			{
			case 10:System.out.print("A");
				break;
			case 11:System.out.print("B");
			break;
			case 12:System.out.print("C");
			break;
			case 13:System.out.print("D");
			break;
			case 14:System.out.print("E");
			break;
			case 15:System.out.print("F");
			break;
			default:
				break;
			}
			else {
				System.out.print(ary[j]);;
			}

		}
		System.out.println();
	}
	public static void print8(int bry[])
	{
		int i;
		for(i = 10;i>=0;i--)
		{
			if(bry[i]!=0)
				break;
		}
		for(int j = i;j>=0;j--)
		{
			System.out.print(bry[j]);
		}
		System.out.println();
	}
	 public static void getx(int num,int ary[],int mod,int wz)
	{
		int l = 0;

		for(int i = 0;i<8;i++)
		{
			int t = num & mod;//16进制的最大值
			ary[l++] = t;
			num = num >>> wz;//4个二进制位表示一个16进制位
		}
	}
}

进制转换示意图

二维数组： 定义一维数组:

  1. int a[] = new int[5];
int a[] = new int[5];

所以定义二维数组 同一维数组
定义方式1：