Java基础06(数组)

1.数组：指的是一组数据(批量)，在内存中是若干个大小一致，类型一样，地址连续的存储空间。提供下标访问元素。（一旦数组被创建，它的大小是固定的）

   1.定义数组（三种格式）

         1)数据类型[] 数组名=new 数据类型[长度];
         2)数据类型[] 数组名=new 数据类型[]{元素1,元素2,....};
         3)数据类型[] 数组名={元素1,元素2,....};

        ！当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创建数组之后就不能再修改它的大小。

        ！当创建数组时，它的元素没被賦予值，则数组元素会被赋予默认值。数值型基本数据类型的默认值为 0, char 型的默认值                 为'\u0000'，boolean 型的默认值为 false。

    2.数组的唯一属性： 数组名.length  可以得到数组的长度

    3.数组的访问：数组元素可以通过下标访问，下标范围是 0  到 数组名.length-1

    4.处理数组：数组的遍历，数组查找，数组扩容，数组排序(选择，冒泡，插入)，具体的实现由以下代码处理：

class Demo03{
    public static void main(String[] args){
        //我们目前所学的数组 大部分是基本数据类型的数组
        //数组有唯一的一个属性 length
        //1.数组的遍历
        bianli();
        //2.数组的查找
        find();
        //3.数组的扩容
        resize();
        //4.数组的排序
        //4.1 选择            时间复杂度O(n^2)    
        selectedSort();
        //4.2 冒泡            时间复杂度O(n^2)    
        bubbleSort();
        //4.3 插入(希尔)       时间复杂度O(n^2) 更好 
        insertSort();
    }
    
    public static void insertSort(){
        int[] arr={5,1,3,2,7,4,9,8,6};
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j=i-1;
            while(j>=0&&arr[j]>e){    //循环条件i的左边要有值且大于e
                arr[j+1]=arr[j];
                j--;
            }
            arr[j+1]=e;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    public static void bubbleSort(){
        int[] arr={5,1,3,2,7,4,9,8,6};
        //i仅仅表示轮数
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
    
    //选择排序
    public static void selectedSort(){
        int[] arr={5,1,3,2,7,4,9,8,6};
        for(int i=0;i<arr.length-1;i++){   //i不用取arr.length
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){     若arr[i]>arr[j]则交换它两的值
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    //数组的扩容
    public static void resize(){
        int[] arr=new int[]{1,2,3,4,5};
        int deltSize=-2;//-缩 +扩
        int[] newArr=new int[arr.length+deltSize];
        //将原先的数据放入到新数组中
        for(int i=0;i<Math.min(arr.length,newArr.length);i++){
            newArr[i]=arr[i];
        }
        arr=newArr;    //偷梁换柱 狸猫换太子 暗度陈仓
        for(int i=0;i<arr.length;i++){    //打印数组
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    //数组的两种查找方法
    public static void find(){
        //线性查找
        //最好情况O(1)
        //最坏情况O(n)
        //平均情况O(n)
        int[] arr={3,2,1,9,5,6,8,7};
        int key=10;//找元素key的角标
        int index=-1;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                index=i;
                break;
            }
        }
        System.out.println(index);

        //二分查找  时间复杂度O(logn)
        // 前提是数组必须是有序的
        arr=new int[]{1,2,3,4,5,6,7,8,9};
        key=10;
        int minIndex=0;
        int maxIndex=arr.length-1;
        int midIndex=(minIndex+maxIndex)/2;
        index=-1;
        while(true){
            if(arr[midIndex]>key){
                maxIndex=midIndex-1;
            }else if(arr[midIndex]<key){
                minIndex=midIndex+1;
            }else{
                index=midIndex;
                break;
            }   
            midIndex=(minIndex+maxIndex)/2;
            if(minIndex>maxIndex){
                break;
            }
        }
        System.out.println(index);
    }
    //数组的遍历
    public static void bianli(){
        //int[] arr=new int[]{1,2,3,4,5,6};
        int[] arr={1,2,3,4,5,6};
        //正序输出数组元素
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        //倒序输出数组元素
        for(int i=arr.length-1;i>=0;i--){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

}

       5.数组练习题：

思路一：使用两个数组，一个是存放数字的数组nums，一个是存放数字出现次数的数组counts  

代码如下：

/*
思路一：
数据：存储数字的数组，存储次数的数组
步骤：
  1、获取一个数字
  2、如果是0.则跳出循环
    如果不是      判断是否在数组nums中
                  在 counts相应位置加一
                   不在   nums扩容   counts也扩容


*/
import java.util.Scanner;
class  Class29{
   public static void main(String args[]){
      int[] nums = new int[0];
      int[] counts = new int[0];
      Scanner Sc = new Scanner(System.in);
      System.out.print("请输入数字：");
      while(true){
        int number = Sc.nextInt(); 
        if(number==0){          //数字等于0，跳出循环
          break;
        }
        int index = indexOf( nums ,number); //查找number在数组nums中的下标 
        if(index!=-1){   
            counts[index]++;      //number在数组nums中，则counts数组中所对应的值++
        }else{                    //number不在数组nums中
            nums  = addnums(nums, number);   //将number加入nums中
            counts = addcounts(counts);     // 对counts也扩容
        }
     

      }


      //输出
      sort(nums , counts);
      for(int i=0;i<nums.length;i++){
        System.out.println(nums[i]+"的次数是"+counts[i]+(counts[i]>1?"times":"time"));
      }
   }

   //使用插入排序对nums排序，counts跟着nums一块移动
   public static void sort(int[] nums,int [] counts){
    for(int i=1;i<nums.length;i++){
      int e=nums[i];
      int f=counts[i];        //附带
      int j=i-1;
      while(j>=0&&nums[j]>e){
          nums[j+1]=nums[j];
          counts[j+1]=counts[j];  //附带
          j--;
      }
      nums[j+1]=e;
      counts[j+1]=f;      //附带
    }
   }

   //获取number在数组nums中的下标
   public static int indexOf(int[] nums ,int number){
       for(int i=0;i<nums.length;i++){
          if(nums[i]==number){
            return i;    //存在返回下标i
          }
       }
       return -1;     //不存在返回-1
   }

   //对数组nums扩容，加入number
   public static int[]  addnums(int[] nums ,int number){
     int[] arr = new int[nums.length+1];
     for(int i=0;i<nums.length;i++){
         arr[i] = nums[i];
     }
     arr[arr.length-1] = number;
     return arr;
   
    }


  //对数组counts扩容  加入1
  public static int[]  addcounts(int[] counts ){
    int[] arr = new int[counts.length+1];
     for(int i=0;i<counts.length;i++){
         arr[i] = counts[i];
     }
     arr[arr.length-1] = 1;
     return arr;
  }
}

思路二：使用一个数组nums，先进行排序，然后对数字计数

代码如下：

import java.util.Scanner;

class Class29_3{
    public static void main(String args[]){
        int[]  arr = new int[0];
        Scanner  Sc = new Scanner(System.in);
        System.out.print("请输入数字：");
        
        while(true){
            int num = Sc.nextInt();
            if(num==0){         //数字为0，跳出循环
                break;
            }
            arr = addnum(arr,num);  //数字不为0，调用函数addnum()   
        }

        sort(arr);  //对数组进行排序
        //输出
        //1 1 2 2 2 2 3 3 4 4 4 5 5
        //i
        //  j
        for(int i=0;i<arr.length;){
            int count = 1;     //对count默认为1
            for( int j =i+1;j<arr.length;j++){
                 
                if(arr[j]==arr[i]){    //若arr[j]=arr[i]则count++
                    
                    count++;
                }else{                //否则跳出循环
                    break;
                }
                    
            }

            System.out.println(arr[i]+"出现了"+count+(count>1?" times":" time"));
            i= i+count;       //将i+count赋给i
        }
    }
    public static int[]  sort(int[] arr){    //选择排序
        for(int i=0;i<arr.length-1;i++){
            for(int j = i+1; j<arr.length;j++){
                if(arr[i]>arr[j]){
                int temp = arr[i];
                    arr[i] =arr[j];
                    arr[j] = temp;
                }
                
            }
        }
        return arr;

    }

    //将num加入到arr数组中
     public static int[]  addnum(int[] arr, int num){
        int[] newarr = new int[arr.length+1];
        for(int i=0;i<arr.length;i++){
           newarr[i] = arr[i];
        }
        newarr[newarr.length-1] = num;
        return newarr;
    }
}

思路三：建立一个下标为0到100的数组 ，使用下标代表1到100的数字

代码如下：

import java.util.Scanner;
class Class29_2{
    public static void main(String args[]){
        int[] arr  = new int[101];        //数组下标代表1到100的数字
        Scanner Sc = new Scanner(System.in);
        System.out.print("请输入数字：");
        while(true){
            int num = Sc.nextInt();
            if(num==0){
                break;        //跳出循环
            }
            arr[num]++;       //下标为num的元素++
        }
        
        for(int i=1;i<arr.length;i++){
            if(arr[i]>0){    //arr[i]大于0 输出，否则不管    
                System.out.println(i+" occurs "+arr[i]+(arr[i]>1?" times":" time"));
            }
        }
    }
}