• Java中数组要点总结


    1、数组是基本数据类型和字符串类型的容器(引用数据类型),而集合是类数据类型的容器;
       
    2、数组定义的格式:
       (1)一般格式:  
           元素类型[] 数组名 = new  元素类型[元素个数或者数组长度];
       其中,元素类型[] 数组名是一个引用数据类型,存放在栈中;
       new  元素类型[元素个数或者数组长度]存放在堆中数组对象,继承自Object。
       (2)定义和静态初始化
            元素类型[] 数组名 = {,,};
     元素类型[] 数组名 = new  元素类型[元素个数或者数组长度]{
      ,,,,,,,};
       注意:别忘了末尾的;
    
    3、未初始化的数组的默认值问题,就是保存的基本类型的默认初始值
     int[] rfInit = new int[3];
     System.out.println(rfInit[0]);//0
     String[] strInit = new String[3];
     System.out.println(strInit[0]);//null
    
    4、数组使用中常见问题
       (1)数组越界:编译没有问题,但运行时报错。
            int[] arr = new int[3];
            System.out.println(arr[3]);
            //ArrayIndexOfBoundsException3:操作数组时,访问到了数组中不存在的角标。
        注:角标的最大值是长度减1;
       (2)数组指向错误
            String[]  strNull = null;
            System.out.println(strNull[0]);
            //NullPointException :空指针异常,当引用没有任何指向为
            null的情况,该引用还在用于操作实体。
    5、数组引用值:
       int[]  a = {1,2,3,4};
       System.out.println(a);
       //结果: [I@1db9742 ,这个就是数组的引用值;其中,
       [ 表示为数组,I 表示存放类型,1db9742哈希值表示在内存中的存放的十六进制地址。
    6、数组操作(算法)
       遍历、最大/最小值、排序(冒泡、选择和直接插入)、查找(折半)、删除数组元素操作和进制转化                 (练习一遍)
       (1)遍历
            int[] arr = new int[3];
        通过数组的属性arr.length可以获取数组的长度。
       (2)最大/最小值:
            a、存放值
            (注:不能把存放最大值的变量赋值为0,因为数组中有负数,就会产生问题。)
     b、存放角标
     (注:存放角标的值可以为0,因为它代表数组的0角标数据)
       (3)排序:从小到大
            a、选择:内循环一次比较,选择出最小的放在最前面,所以减少前面
               比较完的数量;(注:暂时保存最大或者最小值下标,最后再交换是一个
               优化的方法。)
            b、冒泡:内循环一次比较,最小值向前移动,最大值的沉底;所以减少
               后面比较完的数量,
               -x:让每一次比较的元素减少,-1:避免角标越界。
            c、直接插入排序:就是拿出一个空位置,保存起来,接下来把这个位置前面
               的元素和这个位置的值比较;如果大于,就一种元素,如果小于,就结束比较,
               保存元素在现在的位置上。
            注:java中,用Arrays.sort()排序;java中已经定义好的一种排序方式。
               开发中,对数组排序。要使用该句代码。
        (4)查找:折半查找
            先排序,后折半比较;得到相应的数组的下标值。

      

    import  java.util.*;  
      
    class  ArrayTest2{  
        //选择排序  
        public static  void  selectSort(int[] arr){  
            //int temp = 0;  
      
            for(int i=0;i<arr.length-1;i++){        //i下标跟j下标进行比较
                for(int j=i+1;j<arr.length;j++){  
                    if(arr[i]>arr[j]){  //先是第一个数据跟后面的元素都比较完之后(此时,第一个数据绝对是最小的元素),才开始第二个数据与后面的数据进行比较
                        //temp = arr[i];  
                        //arr[i] = arr[j];  
                        //arr[j] = temp;  
                        swap(arr,i,j);  
                    }  
                }  
            }  
        }  
      
        //冒泡排序或者就沉底排序  
        public static void  bubbleSort(int[] arr){  
            //int temp =0;  
            for(int i =0;i<arr.length-1;i++){       //j下标和j+1下标进行比较
                for(int j=0;j<arr.length-1-i;j++){  //-1-i是因为最后一个元素已经确定排好,不用再比较
                    if(arr[j]>arr[j+1]){  
                        //temp = arr[i];  
                        //arr[i] = arr[j];  
                        //arr[j] = temp;  
                        swap(arr,j,j+1);  
                    }  
                }  
            }  
        }  
      
        //优化后的选择排序  
        public static void  optimizeSort(int[] arr){  
            int min;  
            for(int i=0;i<arr.length-1;i++){  
                min =i;  
                for(int j=i+1;j<arr.length;j++){  
                    if(arr[min]>arr[j]){  
                        min = j;      
                    }  
                }  
                swap(arr,i,min);  
            }  
        }  
      
        //直接插入排序
        public static void  insertSort(int[] arr){  
            for (int i = 1; i < arr.length; i++)  
            {  
                //从1角标开始取值,取出一个空位置来  
                if (arr[i - 1] > arr[i])  
                {  
                    //一次插入的过程  
                    int temp = arr[i];  
                    int j = i;  
      
                    //比较移动位置,因为有空位置存在,不会就是元素  
                    while (j > 0 && arr[j - 1] > temp)  
                    {  
                        arr[j] = arr[j - 1];  
                        j--;  
                    }  
      
                    //放在合适的位置上  
                    arr[j] = temp;  
                }  
            }  
        }  
      
        public static void   swap(int[] arr,int x,int y){  
            int temp = 0;  
            temp = arr[x];  
            arr[x] = arr[y];  
            arr[y] = temp;  
        }  
      
        public  static void printArray(int[] arr){  
            System.out.print("[");  
            for(int i=0;i<arr.length;i++){  
                if(i!=arr.length-1)  
                    System.out.print(arr[i]+", ");  
                else  
                    System.out.println(arr[i]+" ]");  
            }  
      
        }  
      
        public static void main(String[] args){  
            int[] a = new int[]{3,1,4,9,6,2};  
            printArray(a);  
      
            //selectSort(a);  
            //printArray(a);  
      
            //bubbleSort(a);  
            //printArray(a);  
      
            //optimizeSort(a);  
            //printArray(a);  
      
            insertSort(a);  
            printArray(a);  
      
            //Arrays.sort(a);  
            //printArray(a);  
        }  
    }  
    

      

  • 相关阅读:
    冲刺阶段(三)
    冲刺阶段(二)
    第十一周学习进度
    冲刺阶段(一)
    第十一周学习进度条
    第一阶段——站立会议总结DAY04
    第一阶段——站立会议总结DAY03
    第一阶段——站立会议总结DAY02
    第一阶段——站立会议总结DAY01
    第十周学习进度条
  • 原文地址:https://www.cnblogs.com/1020182600HENG/p/6560511.html
Copyright © 2020-2023  润新知