CoreJava学习第四课-数组

CoreJava学习第四课-数组

一：数组

1.什么是数组？

​     数组就是 一次性定义多个同类型的变量

2.在内存中,数组元素是连续存储的

​     优点：快速查询到某个数组元素，查询效率高 (下标从0开始计数,提高计算地址的效率)

​     缺点：1.插入和删除效率低 2.数组的长度是固定的 ---------->所以需要数组扩容，见7.数组扩容

3.声明，使用数组【重要】

声明数组: int[] a    int a[]    int []a
​
为数组分配空间：  a = new int[10]; 
                a = new int[]{1,2,5,4,2,6,8,3,4};  显式初始化 直接为数组元素赋值 
注意：定义数组后直接使用可以这样写。
int[] a = new int[]{1，2，3，4，5，6} 等价于 int[] a = {1,2,3,4,5,6}

4.数组遍历

​    现阶段用 for循环遍历 ，后面会学到更多的遍历方式！

for(int i = 0;i < array.length;i++){
   System.out.println(arrsy[i]);
}

5,数组元素默认值

​     每个数组元素都会赋予默认值 (数值类型 0 布尔类型 false 对象类型 null)

6.数组长度

​     数组元素: 数组名[下标] 下标范围: 0 - 数组长度-1

     数组长度: 数组名.length

7.数组扩容

​ 注意：数组变量中存储的是数组的地址,不是数组本身

​ 变量中存储的是数据在内存中的地址，除8种基本数据类型是存储数据的值。

 int[] a = {1,2,3,4,5};//定义一个数组a,长度为5
        System.out.println(a.length);//5
​
        //第1种扩容     
        int[] b = new int[a.length *2 ];
        for(int i = 0 ; i < a.length ; i++){
            b[i] = a[i];
        }
        
        //第2种扩容
        /*System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
          从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。*/
        int[] b = new int[a.length*2];//先定义一个数组b,长度为数组a的2倍
        //需要5个数据（被扩容数组，从第几个元素开始复制，新数组，从第几个元素开始复制，复制多少数据）
        System.arraycopy(a,0,b,0,a.length);
        a = b; 
​
        //第3种扩容 (since JDK 1.6)
        //用Oracle公司提供的函数扩容，直接定义一个新数组，用于扩容
        int[] b = java.util.Arrays.copyOf(a, a.length*2 );//（被扩容的数组，扩容后的长度）
        a = b ; 

二：数组排序

1.冒泡排序法

冒泡排序法: 每次相邻的元素比较 , 每次找出最大的数
          0  1  2  3  4  5
          2  1  4  9  7  5                 a.length=n=6        i=0;i<n-1 i++
j j+1
0-1       1  2  4  9  7  5
1-2       1  2  4  9  7  5
2-3       1  2  4  9  7  5                 i=0            j=0;j<5;j++      
3-4       1  2  4  7  9  5    
4-5       1  2  4  7  5  9
​
0-1       1  2  4  7  5
1-2       1  2  4  7  5                    i=1            j=0;j<4;j++
2-3       1  2  4  7  5
3-4       1  2  4  5  7                                                          j=0;j<n-1-i;j++
​
0-1                                        i=2            j=0;j<3;j++
1-2
2-3
​
0-1                                        i=3            j=0;j<2;j++
1-2
​
0-1                                        i=4            j=0;j<1;j++
    代码实现：
    for(int i = 0 ; i < a.length-1 ; i++){
            for(int j = 0 ; j < a.length-1-i; j++){
                if (a[j] > a[j+1]){
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                }
            }
        }   

 

2.选择排序法

选择排序法: 每次由最左边的元素和剩余所有元素比较   每次找出最小的数
        0   1   2   3   4   5
        8   3   4   2   7   1
                                          for(int i = 0 ; i < n-1 ; i++) 
i j 
0-1     3   8   4   2   7   1
0-2     3   8   4   2   7   1
0-3     2   8   4   3   7   1             i=0       j=1;j<6;j++
0-4     2   8   4   3   7   1
0-5     1   8   4   3   7   2
​
1-2         4   8   3   7   2
1-3         3   8   4   7   2             i=1       j=2;j<6;j++               j=i+1; j<n;j++
1-4         3   8   4   7   2
1-5         2   8   4   7   3
​
2-3             4   8   7   3
2-4             4   8   7   3             i=2       j=3;j<6;j++
2-5             3   8   7   4
​
3-4                 7   8   4             i=3       j=4;j<6;j++
3-5                 4   8   7
​
4-5                     7   8             i=4       j=5;j<6;j++
    代码实现：
    for(int i = 0 ; i < a.length-1 ; i++){
            for(int j = i+1 ; j < a.length ; j++){
                if (a[i] > a[j]){
                    int t= a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }

3.快速排序 --- 调用JDK提供的排序方式！

java.util.Arrays.sort(数组名);

4.二维数组

     二维数组实际上是一维数组的一维数组，可以理解成在一个一维数组里又存了一个一维数组。

     在内存中，一维数组存另一个一维数组的引用 。

public static void main(String[] args){
        //int[][] a = new int[4][3]; 
        /*
        int[][] a = new int[4][];   // int[][] a = new int[][3];error!
        a[0] = new int[4];
        a[1] = new int[5];
        a[2] = new int[3];
        a[3] = new int[6];
        */
        
        int[][] a = {{1,2,3,4},{5,6,7,8,9},{1,1,1},{0,0,0,0}};
        
        //遍历a数组
        for(int i = 0 ; i < a.length ; i++){
            // 遍历a[i]数组
            for(int j = 0 ; j < a[i].length ; j++){
                System.out.print("a["+i+"]["+j+"]="+a[i][j]+"\t");
            }
            System.out.println();           
        }
    }

posted @ 2018-10-11 16:39 ChenPS 阅读( ...) 评论( ...) 编辑 收藏