05 数组

逃离我推掉我的手 2021-10-19 04:46 297阅读 0赞

声明一个变量就是在内存空间划出一块适合的空间
    声明一个数组就是在内存中划出一串连续的空间
    
    数组是相同类型数据的有序集合.
    相同类型的若干个数据,按照一定先后次序排列组合而成。
    其中,每一个数据称作一个数组元素
    每个数组元素可以通过一个下标来访问它们.
    
    
    数组特点:
    其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
    其元素必须是相同类型,不允许出现混合类型。
    数组中的元素可以是任何数据类型，包括基本类型和引用类型。
    位置有顺序
    
    数组属引用类型
    length, elements of the array
    
    一维数组的声明方式有两种：
            type[]  arr_name;
            type  arr_name[];
    
    数组初始化  
    动态初始化
        数组定义与为数组元素分配空间并赋值的操作分开进行。
    int  a[] = null;
    a  = new int[3];
    a[0] = 3;
    a[1] = 9;
    a[2] = 8;
    
    静态初始化：
    除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。
    格式: 类型 []  数组名 = {元素1, 元素2 ……}
    int [] a = {1, 2, 3, 4, 5};
    静态赋值:就是在程序运行之前,就很明确的知道数组中存放的数据是什么,静态赋值不能先声明后赋值,使用new情况除外
    动态初始化：
        动态地从键盘录入数组中的元素
    int [] score = new int[30];
         Scanner input = new Scanner(System.in);
         for (int i = 0; i < 30; i++) {
      score[i]= input.nextInt()
          }
    
    
    数组的界限   
    定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
    数组元素的引用方式：arrayName[index]
    index为数组元素下标，可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
    数组元素下标从0开始；长度为n的数组合法下标取值范围：   0 ~ n-1
    每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)；
     数组的长度: 数组名.length
    
    遍历数组中的元素
    for循环
    //array.length; 数组中元素的个数
    for (int i = 0; i < array.length; i++) {
      System.out.println(array[i]);
    }
    
    
    加强for循环
    //加强for循环  foreach 循环
    //int  指的是数组中元素的类型
    //i 是迭代变量,就是临时变量array1 是数组的名字
      for (int i : array1) {
      System.out.println(i);
      }
    
    
    数组的插入
          元数组为{
         12,34,40,65,89},将56插入到数组中,使数组还保持升序
        步骤    [12,34,45,65,89,0]
        1,找到第一个大于56的数的下标index, 即为56插入的位置
        2,创建一个新的数组长度为原数组+1,使用循环,将原数组的元素拷贝至新数组
        3,新数组从index开始每个元素都后移一位
        4,将56 插入到index位置
    package 数组常用的操作;
    /**
     * 
     * @author Administrator
     *
     */
    
    public class Test02 {
        public static void main(String[] args) {
            int [] arr01 = {12,34,40,65,89};
            //创建一个新的数组，长度为原数组长度加1
            int [] arr02 = new int[arr01.length+1];
            //将原数组的元素一一拷贝到新数组中
            for (int i = 0;i<arr01.length;i++){
                arr02[i] = arr01[i];
            }
            //[2]在arr02找到第一个比56大的数组 保存下标
            int index = 0;
            for(int i =0;i<arr02.length;i++){
                if (arr02[i] >56){
                    index = i ;
                    break;
                }
            }
            //[3]从index开始 所有元素都往后移动一位
            //[12,34,40,65,89,0]
            for (int i =arr02.length-1; i> index ;i--){
                arr02[i] = arr02[i-1];
            }
            //【4】将56插入到index的位置
            arr02[index] = 56;
            
            for(int i:arr02){
                System.out.println(i);
            }
        }
    
    }
    
    
    冒泡排序
    package 数组常用的操作;
    
    public class MaoPao {
        public static void main(String[] args) {
            int [] arr = {91,10,31,109,2,33};
            for (int i = 0;i < arr.length-1;i++){
                //外层循环循环一次 冒出来一个最值 ，长度为n 的数组 冒出来n-1个最值就可以排好序了
                //所以判断条件是i < arr.length-1;
                for (int j = 0;j < arr.length-i-1;j++){
                    //因为外层循环循环一次就冒出来一个最大值 该最大值就不用在参与比较了
                    //所以判断条件后面要 -i
                    //又因为在内存循环中每次取出两个元素 一个下标为j 一个下标为j+1
                    //所以j最大值只能取到arr.length-2;
                    //j+ 1的值最大就是arr.length -1 就是最后一个元素了
                    int n1 = arr[j];
                    int n2 = arr[j+1];
                    //比较两个元素 如果前者大于后者 则交换位置
                    if(n1 > n2){
                        arr[j] = n2;
                        arr[j+1] = n1;
                    }
                    
                }
                
            }
            for(int i :arr){
                System.out.println(i);
            }
        }
    
    }

转载于:https://www.cnblogs.com/meizhoulqp/p/11246531.html