java 数组

• 一维数组

• package array;
  
  public class TestArray {
  	
  
  	public static void main(String[] args) {
  	
  		System.out.println("hello world ！");
  		/**
  		 *   1、一维数组的使用 ； 
  		 *   数组是相同类型的集合，实现对这些数据的统一管理；
  		 *   数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型 ；
  		 *   数组属于引用类型，数组型数据是对象，数组中的每个元素相当于该对象的成员
  变量。
  		 *  数据一旦初始化，其长度是不变的 ；
  		 */
  //		1、如何定义一个数组
  		String[] names ; 
  		int[] scores ; 
  //		1.2初始化
  //	 	静态初始化:初始化数组与给数组元素赋值同时进行 ； 
  		names= new String[]{"曹真","尚晓飞","周雅"} ; 
  //		动态初始化：初始化与赋值分开进行 ； 
  		scores = new int[4] ;
  //		2.如何调用相应的数组元素 ； 通过数据元素的下角标
  //		下角标从0开始，到 n-1 结束，n代表数据的长度 ； 
  		scores[0] = 78 ; 
  		scores[1] = 98 ; 
  		scores[2] = 94 ; 
  //		数组的长度：通过数组的length属性；
  		System.out.println(scores.length);//4
  		System.out.println(names.length);//3
  //		如何遍历数组元素；
  		for (int i = 0; i < scores.length; i++) {
  			System.out.println(scores[i]);
  			
  		}
  		
  
  		/**
  		 * 数组元素的默认初始化值；
  		 * 对于基本类型的数据创建数组 ； 
  		 * byte short int long  double float chart boolean
  		 */
  //		1、对于byte short int long 而言,创建数组以后默认值为0 ；
  		int[] scores1 = new int[4] ;
  		scores1[0] = 12 ; 
  		scores1[1] = 45 ; 
  		for (int i = 0; i < scores1.length; i++) {
  			System.out.println(scores1[i]);
  		}
  		
  //		2、对于float double 而言，默认值是0.0 ； 
  		float[] f = new float[3] ;
  		for (int i = 0; i < f.length; i++) {
  			System.out.println(f[i]);
  		}
  		
  //		3、对于char而言，默认空格；
  		char[] c = new char[3] ; 
  		for (int i = 0; i < c.length; i++) {
  			System.out.println(c[i]);
  		}
  //		4、对于boolean 而言，默认类型为 false ;
  		boolean[] b = new boolean[3] ;
  		for (int i = 0; i < b.length; i++) {
  			System.out.println(b[i]);
  			
  		}
  		
  //		5、对于引用类型的变量构成的数组而言，默认值为null，以String 为例 ； 
  		String[] strings = new String[4] ; 
  		strings[0] = "AA" ;
  		strings[1] = "BB" ;
  //		strings[2] = "CC" ;
  		strings[3] = "DD" ;
  		for (int i = 0; i < strings.length; i++) {
  			System.out.println(strings[i]);
  		}
  		
  		
  		/**
  		 * 一维数组的内存结构 ； 
  		 */
  		
  		
  	}
  	
  }
  

  内存的基本结构

• 

• 一维数组的内存结构：

• 

• 多维数组

public class TestArray2 {
	
	public static void main(String[] args) {
		int[] scores = new int[10] ;
		int[][] scores2 ; 
		String[][] names ;
//		1、二维数组的初始化 ； 
		scores2 = new int[][]{{1,2,3,},{4,5},{16}} ; //静态初始化 ；
		 
		names = new String[6][5] ;// 方式一
		names = new String[6][] ;// 方式二 
		names[0] = new String[2] ;
		names[1] = new String[5] ; 
		names[2] = new String[3] ;
		names[3] = new String[5] ; 
		names[4] = new String[3] ; 
		names[5] = new String[6] ; 
		
//		2、如何引用具体的某个元素 ； 
		int[][] i = new int[3][2] ; 
		i[0][1] = 10 ; 
		i[1][0] = 50 ; 
//		3、数组的长度 ； 
//		二维数组的长度  length 属性
		System.out.println(i.length);//3
		System.out.println(i[0].length) ;//2 
		System.out.println(names.length);//6
		System.out.println(names[4].length);//3 
		
//		4、如何遍历数组 ； 
		for (int j = 0; j < i.length; j++) {
			for (int j2 = 0; j2 < i[j].length; j2++) {
				System.out.print(i[j][j2]+"\t");
			}
			System.out.println();
		}
		
		for (int j = 0; j < names.length; j++) {
			for (int j2 = 0; j2 < names[j].length; j2++) {
				System.out.print(names[j][j2]+"\t");
			}
			System.out.println("");
			
		}
//		5、二维数组的内存 ；
		
		
		
		
	}

}

多维数组的内存  

冒泡排序

private static int[] sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            //通过标识来缩短比较的次数；
            boolean flag = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tem = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tem;
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }
        return arr;
    }

稀疏数组

 

  public static void main(String[] args) {
        
        //初始化11*11的数组； 
        int[][] array = new int[11][11];
        array[0][2] = 1;
        array[2][3] = 2;
        for (int[] ints : array) {
            for (int i : ints) {
                System.out.print(i + "\t");
            }
            System.out.println("");
        }
        System.out.println("********************************************");
        // 将数组转换成稀疏数组
        // 获取稀疏数组有效值；
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        //创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }
        }
        //打印稀疏数组
        for (int[] arr : array2) {
            for (int i : arr) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
        System.out.println("********************************************");
        
        //还原稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印还原的数组
        for (int[] ints : array3) {
            for (int i : ints) {
                System.out.print(i + "\t");
            }
            System.out.println("");
        }

    }