基础班--day04

1.作业

package cn.itcast.day04.作业;

import java.util.Random;

public class A六个随机数放入数组并求和 {
    public static void main(String[] args) {
        Random rd=new Random();
        //100以内的随机数
        int []arr=new int[6];
        for (int i = 0; i < arr.length; i++) {
            //循环给数组赋值
            int num = rd.nextInt(101);//随机数要随机产生六个，放在循环中
            System.out.println(num);
            arr[i]=num;
        }
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum);
    }
}

package cn.itcast.day04.作业;

public class A计算的平均值为小数 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5,6};
        double sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        //avg是平均数
        //arr.length是数组长度
        double avg=sum/arr.length;
        System.out.println(avg);
    }
}

package cn.itcast.day04.作业;

import java.util.Scanner;

public class A键入整数放入数组并从小到大排列01 {
    public static void main(String[] args) {
        //1.定义长度为10的原数组
        int []arr={10,20,30,40,50,60,70,80,90,100};
        //2.定义长度为11的空数组
        int []brr=new int[arr.length+1];
        //3.键盘录入数组
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个整数数字");
        int num = sc.nextInt();
        //4.定义变量代表要插入的位置
        int index=0;
        //5.循环遍历原数组
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<=num){
                //5.1如果元素小于等于要插入的数字，则直接存放
                brr[i]=arr[i];
                //5.2把i后面的位置记录下来
                index=i+1;
            }else{
                //5.3如果元素大于要插入的数字,则往后一个位置存放
                brr[i+1]=arr[i];
            }
        }
        //6.index存储的就是要插入的位置
        brr[index]=num;
        //7.遍历新数组查看结果
        System.out.print("生成的新数组是：");
        for (int i = 0; i < brr.length; i++) {
            System.out.print(brr[i] + " ");
        }
    }
}

package cn.itcast.day04.作业;

import java.util.Scanner;

public class A键入整数放入数组并从小到大排列02 {
    public static void main(String[] args) {
        int []oldArr={12,14,23,45,60,68,70,77,90,91};
        int []newArr=new int[oldArr.length+1];

        int index=0;

        Scanner sc=new Scanner(System.in);
        System.out.println("请您输入一个整数：");
        int num=sc.nextInt();

        for (int i = 0; i < oldArr.length; i++) {
            if(oldArr[i]<num){
                newArr[i]=oldArr[i];
                index++;
            }else{
                newArr[i+1]=oldArr[i];
            }
        }
        newArr[index]=num;

        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i]+" ");
        }
    }
}

package cn.itcast.day04.作业;

public class 奇数放左偶数放右 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5,6,7,8,9};
        //2.定义空数组
        int []brr=new int[arr.length];

        //如果元素是奇数，则放在新数组brr的左边，left变量加一。
        // 如果元素是偶数，则放在新数组brr的右边，right变量减一。

        //3.定义变量代表奇数要存放的位置
        int left=0;
        //4.定义变量代表偶数要存放的位置
        int right=arr.length-1;
        //5.对原数组进行遍历
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%2==1){
                //5.1如果是奇数就往左边放
                brr[left]=arr[i];
                //5.2存放之后让索引向右移动
                left++;
            }else{
                //5.3如果是偶数就往右边放
                brr[right]=arr[i];
                //5.4存放之后让索引向左移动
                right--;
            }
        }
        //6.打印brr数组
        for (int i = 0; i < brr.length; i++) {
            System.out.print(brr[i]+"");
        }
    }
}

package cn.itcast.day04.作业;

public class 小数最小值 {
    public static void main(String[] args) {
        //小数用double
        double[]arr={13.14,5.21,0.521};
        double min=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min>arr[i]){
                min=arr[i];
            }
        }
        System.out.println("最小值是"+min);
    }
}

package cn.itcast.day04.作业;

public class 数组的元素组成一个整数 {
    public static void main(String[] args) {
        int []arr={5,2,1,1,3,1,4};
        int num=0;
        for (int i = 0; i < arr.length; i++) {
            //十位就是元素加一个0，百位就是元素加两个0
            //把num的值乘10再加上元素的值，赋值给num变量
            num=num*10+arr[i];
        }
        System.out.println(num);
    }
}

2.快捷键

package cn.itcast.day04.快捷键;
/*
   快捷键：
   Alt+Enter       导入包，自动修正代码
   ctrl+Y           删除光标所在行
   ctrl+D           复制光标所在行的内容，插入光标位置下面
   ctrl+Alt+L        格式化代码,排版
   ctrl+/            单行注释
   ctrl+shift+/      选中代码注释，多行注释，再按取消注释
   Alt+shift+上下箭头  移动当前代码行



   ctrl+alt+m   方法补全快捷键
 */
public class 快捷键01 {

}

3.扩展

package cn.itcast.day04.扩展;
/*
* 需求：
*     定义一个数组{1，2，3，4，5}，遍历数组，输出格式按照[1,2,3,4,5]
* */
public class tz01按格式输出 {
    public static void main(String[] args) {
        int [] arr ={1,2,3,4,5};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

package cn.itcast.day04.扩展;
/*
定义数组{3，2，4，6}，求出数组中元素的和
步骤：
1定义一个数组
2定义一个变量sum，接收两个数的和
3遍历数组，将每一个元素获取出来，两两相加
 */
public class tz02求和 {
    public static void main(String[] args) {
        int []arr={3,2,4,6};
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum);
    }
}

package cn.itcast.day04.扩展;
/*
找出最大值
步骤：
1定义数组
2定义一个变量，接收数组中的第一个元素
3遍历数组，将每一个元素获取出来
4拿着max跟遍历出来的元素比较，如果遍历出来的大，将大的重新赋值给max
5直接输出max
*/

public class tz03最大值 {
    public static void main(String[] args) {
        int [] arr={1,6,8,2,};
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){
                max=arr[i];
            }
        }
        System.out.println(max);
    }
}

4.数组

package cn.itcast.day04.数组;
/*
    数组：是一种用于存储多个相同类型数据的存储模型

    定义格式：(推荐方式)
        数据类型[] 数组名;
        举例：int[] arr;

    数组初始化：
        A:所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
        B:数组初始化
            动态初始化
            静态初始化

    动态初始化：
        初始化时只指定数组长度，由系统为数组分配初始值
        格式：数据类型[] 变量名 =  new  数据类型[数组长度];
        范例：int[] arr = new int[3];
 */
public class 数组01动态初始化 {
    public static void main(String[] args) {
        int[] arr=new int [3];
        /*
            左边：
                int:说明数组中的元素类型是int类型
                []:说明这是一个数组
                arr:这是数组的名称
            右边：
                new:为数组申请内存空间
                int:说明数组中的元素类型是int类型
                []:说明这是一个数组
                3:数组长度，其实就是数组中的元素个数
         */
        //输出数组名
        System.out.println(arr);
        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

package cn.itcast.day04.数组;

/*
    单个数组
          整数:0
         小数:0.0
         字符:'\u0000'
         布尔:false
         引用:null

 */
public class 数组02单个赋值 {
    public static void main(String[] args) {
        int [] arr=new int [3];
        //输出数组名及元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("-------------------");
        //给数组中的元素赋值
        arr[0]=100;
        arr[2]=200;
        //再次输出数组名及元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

package cn.itcast.day04.数组;
/*
    多个数组
 */
public class 数组03多个数组赋值 {
    public static void main(String[] args) {
        //定义两个数组
        int [] arr=new int[3];
        int [] arr1=new int[3];
        //分别输出数组名及元素
          System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println(arr1);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //然后分别给数组中的元素赋值
        arr[1] = 100;
        arr1[0] = 200;
        arr1[2] = 300;

        //分别再次输出数组名及元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[2]);
    }
}
   /* int []arr1=new int [3];
    int []arr2=new int [3];
        arr1[0]=10;
                arr2[1]=20;
                System.out.println(arr1[0]);
                System.out.println(arr2[1]);
                for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
        }
        for (int i = 0; i < arr2.length; i++) {
        System.out.println(arr2[i]);
        }
       */

package cn.itcast.day04.数组;
/*
    静态初始化：
        初始化时指定每个数组元素的初始值，由系统决定数组长度

        格式：数据类型[] 变量名 =  new  数据类型[]{数据1, 数据2, 数据3, ……};
        范例：    int[]   arr =  new      int[]{1, 2, 3};

        简化格式：数据类型[] 变量名 = {数据1, 数据2, 数据3, ……};
        范例：       int[]    arr = {1, 2, 3};
 */
public class 静态初始化 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3};

        //输出数组名
        System.out.println(arr);

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

5.数组的遍历

package cn.itcast.day04.数组的遍历;
/*
数组的遍历：
     将数组中的每一个元素挨个获取出来

 */
public class 挨个获取出来 {
    public static void main(String[] args) {
        String[] arr={"a","b","c","d","e"};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println("-------------------");
        for (int i=0;i<5;i++){
            System.out.println(arr[i]);
        }
        System.out.println("**************");


        //这就是遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}