一维数组的基本使用

一维数组的基本使用

数组的定义:一系列具有相同的数据类型的数据集合
注意：定义使用一个数组需要知道数组的数据类型以及数组的长度
一般数组的下标从0开始，最大下标为长度-1，当要运行超出数组长度的值是，就会出现下标溢出的异常，如下面的代码

public class Test_01 {
    /**
     * 主程序（主程序的入口）
     * @param args
     */
    public static void main(String[] args) {
        //定义一个数组 确定数据类型，数组长度
        int[] a=new int[5];
        a[0]=10;
        a[1]=11;
        a[4]=14;
       // a[5]=15;//第六个位置
        /**
         * ArrayIndexOutOfBoundsException:下标溢出异常
         */
        int a0=a[0];
       // System.out.println(a0);

（1）数组与循环
1）通过数组输入

int nums[]=new int[5];
        //实例化对象输入
        Scanner sc=new Scanner(System.in);
        //通过数组输入
        for (int i=0;i<nums.length;i++){
            System.out.println("请输入第"+(i+1)+"个值");
            nums[i]=sc.nextInt();
        }

2）通过数组赋值

 //利用循环赋值
        for (int i=0;i<nums.length;i++){
            //i为数组下标
            nums[i]=i;
        }

3）循环遍历数组

//利用循环遍历数组
        for (int k=0;k<nums.length;k++){
            int b=nums[k];
            System.out.print(b+"\t");
        }

4)foreach循环遍历数组

//foreach循环遍历数组
        for(int j:nums){

        }

（2）数组与随机数的实现
1） 利用数组与随机数实现，创建随机数产生-5~5的整数存放到数组as中，完成后，输出数组的值和总数和sum，最大值max,最小值min,保留两位小数的平均值avg

 public static void method03(){
        int[] as=new int[7];
        int len=as.length;
        int sum=0,max=as[0],min=as[0];
        double avg=0;
        Random r=new Random();
        for (int i=0;i<len;i++){
         //11为界限，-5为开始值：表示从-5~5的11个数之间
            as[i]=r.nextInt(11)-5;
            if(max<as[i]){
                max=as[i];
            }
            if(min>as[i]){
                min=as[i];
            }
            sum+=as[i];
        }
        //强转：通过对象转换；例如Integer.parseInt()
        //显示转换：通过数据类型转换；例如(double)
        avg= ((sum*100/len)*1.0D)/100;
        //转换成字符串
        DecimalFormat df=new DecimalFormat("0.##");
        double d=(double) 5/2;
        System.out.println(df.format(d));
//        for (int a:as){
//            System.out.print(a+"\t");
//        }
        //通过字符串的形式输出
        System.out.println(Arrays.toString(as));
        System.out.println("最大值："+max);
        System.out.println("最小值:"+min);
        System.out.println("总和:"+sum);
        System.out.println("平均值:"+avg);
    }

（3）工具类Arrays的基本使用

public static void method04(){
        /**
         * int num[]=new int[2];
         * 实例化数组，初始值为0
         */
        //实例化数组且赋值
        int as[]={12,45,78,36,69,57};
        String strArray=Arrays.toString(as);
        System.out.println("数组转换为字符串："+strArray);

        //数组长度自动递增
        as=Arrays.copyOf(as,as.length+2);
        System.out.println("数组转换为字符串："+Arrays.toString(as));
        //复制粘贴 ctrl+alt+向上或者向下
        //剪切一行 ctrl+d
        as[as.length-1]=120;
        System.out.println("增加最大长度的值后字符串："+Arrays.toString(as));

        //数组的排序，目前最快的排序，没办法优化，因为进行了高度封装
        //只能升序（从小到大排序）
        Arrays.sort(as);
        System.out.println("排序后字符串："+Arrays.toString(as));
        //转置：位置交换(int as[]={12,45,78,36,69})
        for (int i=0;i<as.length/2;i++){
            int c=as[i];
            as[i]=as[as.length-1-i];
            as[as.length-1-i]=c;
        }
        System.out.println("转置后字符串："+Arrays.toString(as));

    }

（4）数组的冒泡排序
冒泡排序的思想：比较相邻的两个数，如果按照顺序排序，当前的数a，比较后面的数b大是， 交换位置，第一轮过后，最大的值会排在数组的最后面，经过n-1轮完成排序

public static void method05(){
        int nums[]={12,1,4,2,58,49};
        System.out.println("排序前："+Arrays.toString(nums));
        int len=nums.length;
        //外循环，比较轮次,每次找到最大值
        for(int i=0;i<len-1;i++){
            //内循环，每一个数的比较
            for (int j=0;j<len-1-i;j++){
                int a=nums[j];
                int b=nums[j+1];
                if(a>b){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        System.out.println("排序后："+Arrays.toString(nums));
    }

（5）数组的选择排序
选择排序的思想：数组的每一个值（外循环）与数组中的每一个（内循环）值做对比，如果按照顺序排序，当第一个数a比这个数b大是，交换位置，第一轮过后，最小的排在前面，经过n-1轮完成排序

public static void method06(){
        int nums[]={45,6,23,6,8,4,234};
        System.out.println("排序前："+Arrays.toString(nums));
        for(int i=0;i<nums.length-1;i++){
        //选择比较和下标i不同的数
            for (int j=i+1;j<nums.length;j++){
                int a=nums[i];
                int b=nums[j];
                if(a>b){
                    int temp=nums[i];
                    nums[i]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        System.out.println("排序后："+Arrays.toString(nums));
    }

（6）判断数组中的重复值
1）判断输入的某个值在数组中是否出现

public static void method01(){
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入一个数：");
        int a=sc.nextInt();

        int as[]={2,12,45,78,385,87,5,2,4};
        boolean flag=false;
        //遍历数组
        int len=as.length;
        for (int i=0;i<len;i++){
            int b=as[i];
            if (a==b){
                flag=true;
                break;
            }
        }
        if(flag){
            System.out.println("值存在了！");
        }else{
            System.out.println("值不存在！");
        }
    }

2)判断数组中的内容是否重复

public static void method02(){
        //字符串数组中的整数会被转回为ascII值
        char[] as={'a','b',45,'c','d',96,1};
        boolean flag=false;
        //A为安全点，一般用于多重循环
        A:for(int i=0;i<as.length;i++){
            for (int j=i+1;j< as.length;j++){
                char a=as[i];
                char b=as[j];
                if (a==b){
                    flag=true;
                    break A;  //跳出一个循环
                }
            }
        }
        if (flag){
            System.out.println("出现重复！");
        }else {
            System.out.println("没有出现重复！");

        }
    }

3)判断数组中的内容重复多少个值

    public static void method03(){
        double[] as={12.3,12,7,12.3,7,7,7,7,7,15};
        double[] sc={};
        for(int i=0;i< as.length;i++){
            double a=as[i];
            boolean flag=false;
            for (int j=i+1;j< as.length;j++){
                double b=as[j];
                if (a==b){
                    flag=true;
                    break;
                }
            }
            if(flag){
                for(double n:sc){
                    if(n==a){
                        //false代表存在
                        flag=false;
                        break;
                    }
                }
                if(flag){
                    //数组自动增长
                    sc= Arrays.copyOf(sc,sc.length+1);
                    sc[sc.length-1]=a;
                }

            }
        }
        System.out.println("重复值："+Arrays.toString(sc));
        for (double x:sc){
            System.out.println(x+"的重复的个数为："+map.get(x));
        }
    }

4）用Map集合计算重复值的个数

  public static void methode04(){
        double[] as={12.3,12,7,12.3,7,7,7,7,7,15};
        int len=as.length;
        Map<Double,Integer> map=new HashMap<>();
        for(int i=0;i<len;i++){
            double a=as[i];
            if(map.containsKey(a)){
                int val=map.get(a);
                map.put(a,val+1);
            }else {
                map.put(a,1);
            }
        }
        System.out.println("重复的个数："+map.get(7.0));
    }

（7）利用上面基本知识实现的练习

   /**题目：
     * 对数组进行奇数倒叙排序，偶数进行顺序排序，不改变数组奇偶数的位置
     * 0既不是奇数也不是偶数
     */
    public static void method() {
        int as[] = {12, 45, 89, 12, 0, 12, 3, 6, 5, 9, 8, 10, 13};
        int len = as.length;
        System.out.println("排序前："+Arrays.toString(as));

        //奇数排序
        for (int i = 0; i < len - 1;i++ ) {
            if(as[i]%2==0||as[i]==0){
                continue;
            }
            for (int j = i + 1; j < len;j++ ) {
                int a = as[i];
                int b = as[j];
                if(a<b&&b%2==1){
                    int temp=as[i];
                    as[i]=as[j];
                    as[j]=temp;
                }

            }
        }
        System.out.println("奇数排序后：" + Arrays.toString(as));

        //偶数排序
        for (int i = 0; i < len - 1;i++ ) {
            if(as[i]%2==1||as[i]==0){
                continue;
            }

            for (int j = i + 1; j < len;j++ ) {
                int a = as[i];
                int b = as[j];
                if(a>b&&b%2==0&&b!=0){
                    int temp=as[i];
                    as[i]=as[j];
                    as[j]=temp;
                }

            }
        }
        System.out.println("偶数排序后：" + Arrays.toString(as));
    }
}