java数组知识整理

Java数组知识点归纳

---

• 数组的概念: 数组是用来存储一系列数据类型一致的数据且长度固定的容器

• 数组的定义:

  • 格式：数据类型[] 数组名 = new 数据类型[ 数组长度];

          int[] arr = new int[10]; 第一种写法（推荐） 
          int arr[] = new int[10];
    

• 数组的初始化：

  • 静态初始化 (定义数组时，不指定存储空间，系统自动分配)

    int[] arr = new int[]{2, 4,  6, 8}; 第一种写法(推荐使用,在逻辑上更符合语义，增加可阅读性)
    
    int[] arr2 = {1, 3, 5, 7,9};//第二种写法
    

  • 动态初始化： (定义数组时指定内存空间，进行动态赋值)

    int [] arr = new int[5];
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    ...
    

• 数组的固有属性length：获取数组的长度

  int[] arr = new int[]{2, 4, 6, 8};
  System.out.println(arr.length)；//  输出4，数组的长度为4
  

• 数组在内存中的存储：

int[] arr = new int[3]//[I@5f150435
                        //数组变量存储在栈内存中，new创建的数组对象存储在堆内存中
                        //arr 引用的是数组对象在堆内存的内存地址(16进制)
System.out.println(arr)

• 数组的默认缺省值：
  • 整数：0
  • 浮点型：0.0
  • 字符型：‘\u0000’
  • 布尔型：false
  • 引用类型：null
• 数组的遍历:

  //遍历一维数组 普通for循环
  	int[] arr = new int[]{12, 20, 9, 44, 80, 37};
  	for(int i=0; i

• 数组的应用

  • 求数组中的最大/最小值

  • **实现思路:**假设数组为一个舞林大会，数组元素就是各路英雄，假设首先上场的人（arr[0]）为武林盟主，让其与其他人进行比武，打赢了继续与下一个比武，打输了武林盟主就是打赢它的人(arr[1])，然后让arr[1]继续与其他人比较，以此类推，最后会获得一个武功最高的人，也就是最大值

    	public class ArrayTest {
    	public static void main(String[] args) {
    		
    		int[] arr = new int[]{6,8,2,7,9};
    		int max = arr[0]; //假设数组首位是最大值
    		for(int i=1; i

  • 数组元素反转

    • 实现思路： 设置一个循环每次循环都让数组的最小下标和最大下标对应的值进行交换 比如数组{1, 2, 3, 4, 5}第一次1和5交换，第二次2和4交换 剩下的3不用动，可以发现，不管是偶数个还是奇数个元素数组都是需要交换(arr.length)/2次 每次交换完成后当min条件满足时 min++ , max-- 当上述条件不满足时，交换结束，遍历数组元素查看反转结果

      	public static void main(String[] args) {
      		int[] arr = new int[]{1,2,3,4,5};
      		int min = 0; //第一个元素的下标
      		int max = arr.length-1;  //最后一个元素的下标
      		for(int i=0; i<(arr.length)/2; i++){
      			int temp = arr[min]; //第一个元素给tmep
      			arr[min] = arr[max];  //最后一个元素给了最第一个元素
      			arr[max] = temp; 	//temp中的第一个元素给了最后一个元素
      			if(min

  • 冒泡排序法:

  • 思路讲解： 让一个数组中的数据第一个元素和第二个元素比较，如果第一个元素大于第二个元素则他们的位置交换，反之位置不变，if(arr[0]>arr[1])那么让他们位置交换，并让原本处于arr[0] (现在位于arr[1])的数继续和arr[2]比较,以此类推

  • 总结一下思路: 首先看内循环，内循环执行一次(j = 0)比较两个元素的大小，而且总会使较大的那个元素位置处于前面()再执行(j=1)时会让第二个元素与第三个元素比较，让其中较大的值往前移动位置。以此类推，当内循环执行结束时 总共要两两比较arr.length-1次，然后确定数组 中一个最大值置于数组末位，第二轮内循环(i=1)时， 再确定一位第二大值放置在数组的倒数第二位，而且第二轮内循环的比较次数为arr.length-2次 第三次内循环(i=2)时，再次确定一个数放在倒数第三的位置此轮内循环比较次数为arr.length-3

  • 得出的结论 每一轮内循环得到一个最大值放在末位，一共要进行的内循环次数(外循环的次数)为arr.length-1次，外循环每执行一次内循环执行一轮，得到一个最大值，而且内循环的执行次数减1(因为每一轮内循环获得一个值，意味着少比较一次，也就是内循环少跑一次)

public class ArrayTest {
	public static void main(String[] args) {
		//冒泡排序法
		int[] arr = new int[]{12, 20, 9, 44, 80, 37};
		for(int i=0; iarr[j+1]){							//因为外循环每跑一次 确定一个值，内循环一轮中比较次数也就减一次
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}

• 选择排序法
  • 思路： 设定第一个元素的下标为最小值的下标，也就是说第一个元素arr[0]，一直都是最小值，让第一个数和第二个数进行比较。如果前者大于后者，那么后者的下标就是最小值的下标，意味着它是最小值，内循环一轮结束，就会得到一个最小值的下标，再把最小值下标的那个数与首个元素arr[0]进行交换，最小值就到了第一个元素的位置，每轮确定一个，确定arr.length-1次,//也就是外循环的次数，就会得到一个升序序列

  //选择排序法 
  int[] arr = new int[]{12, 20, 9, 44, 80, 37};
  	for(int i=0; iarr[j]){
  				min = j;
  			}
  		}   
  		if(min!=i)
  		{
  			int temp = arr[min];
  			arr[min] = arr[i];
  			arr[i] = temp;
  		}										
  	}
  	System.out.println(Arrays.toString(arr));