day 05 数组

1.数组

1.1 数组特点

 A 数组中的数据类型要一致，可以是基本数据类型，也可以是引用数据类型
 B 数组下标从0开始，一直到n-1结束

1.2 数组声明

 int[]  array; //声明一个整型数组，数组名叫array;
 int    array[]; //声明一个整型变量，变量为数组，数组名为array;

1.3 数组的创建与初始化

  1.动态初始化---只确定数组长度，不确定数组元素
  
	int[] array=new int[n]; //n表示数组中元素的个数，确定了数组元素个数，可以不放满，

  2.静态初始化---确定所有数组元素，由Java自己确定长度
  
    int[] array={1,2,34,56,7,8}; // 用确定的集合初始化数组
    int[] array=new int[]{1,2,34,5,7}; //用具体的集合初始化数组，确定了全部具体的数组元素，已经放满了

1.4 数组注意事项

	1.⽆论是哪⼀种创建的⽅式都需要指明数组的⻓度，⽆论是显式的还是隐式的
	2.数组的⻓度⼀旦定义了，固定不变
	3.数组属于引⽤数据类型
	4.数组中元素必须是同⼀种数据类型

1.5 数组数据类型的默认值

整数型：int 类型默认值为 0；
浮点型：float double 类型默认值为0.0；
布尔型：boolean 默认值为false;
字符型：char类型默认值为十六进制数  '\u0000' ;
引用型：所有的引用数据类型默认为null;

1.6 数组的常见操作

 1.给数组中的元素赋值
   
   	array[2]=33;
   	
 2.获取数组长度
   	
   	int length=array.length;
   	
 3.查看数组中的每一个元素
 
  	3.1 直接输出
	  	System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        
    3.2  for循环
 	  for(int i=0;i<array.length;i++){
    	System.out.println(array[i]);
	  }

1.7 数组测试使用

//创建大小在10~20之间的数组，用0到100之间的数据填充数组，输出结果

	public class ArrayTest {
	    public static void main(String[] args) {
	        Random random=new Random();
	        //10到20之间的数，包含20
	        int count=(int)(random.nextDouble()*(21-10)+10);
	        int[] array5=new int[count];
	        for(int i=0;i<array5.length;i++){
	        //每赋值一次，获取一次随机数，保证数据元素不完全相同
	            int num=random.nextInt(100);
	            array5[i]=num;
	        }
	        System.out.println(Arrays.toString(array5));
	    }
	}

1.8 数组的内存模型

 1.先声明数组，声明的数组在栈内存中开辟一块区域，默认值为null;
 2.初始化数组，new方法在堆内存中开辟一块区域，给区域中的每个元素赋值，将这块区域的首地址传递给数组变量；

1.9 数组的遍历

 //求数组中的最大值
 
 public class ArrayMaxValue {
    public static void main(String[] args) {
        int[] array=new int[]{1,3,6,4,7,234,7685,23,38,87,3};
        //定义一个变量，存放最大值
        int max=array[0];
        //默认第一个元素最大，直接从第二个元素比起
        for(int i=1;i<array.length;i++){
            //定义一个变量，存放当前正在遍历的数组元素
            int temp=array[i];
            if(max<temp){
                //将较大值赋值给max
                max=temp;
            }
        }
        System.out.println(max);
    }
}

	//10到20个成绩，求最大最小
public class StudentScoreMinAndMax {
    public static void main(String[] args) {
        Random random=new Random();
        int  count=random.nextInt(10)+10;
        Scanner scanner=new Scanner(System.in);
        double[] array=new double[count];

        for (int i=0;i<count;i++){
        System.out.println("请输入学生成绩：");
        double score=scanner.nextDouble();
        array[i]=score;
    }
    System.out.println(Arrays.toString(array));
    //将赋值之后的第一个元素赋值给变量
    double min=array[0];
    double max=array[0];
    for(int j=0;j<array.length;j++){
        if(max<array[j]){
            max=array[j];
        }
        if(min>array[j]){
            min=array[j];
        }
    }
    System.out.println("最小值是："+min);
    System.out.println("最大值是："+max);
    scanner.close();
    }
}

1.10 反转数组

 1.使用左右计数的方式，一直循环，当进行到中间时，停止循环
 
 public class ArrayTurnAroundDemo {
    public static void main(String[] args) {
	        int[] array=new int[]{12,4,6,7,2,76,45,2,782,3};
	        
	 A：   ***int left=0;
        	int right=array.length;
           for(int i=0;i<array.length;i++){
		            int temp=array[i];
		            array[i]= array[array.length-i-1];
		            array[array.length-i-1]=temp;
		            left++;
		            right--;
		            if(left>right){
		                break;
        }***
        
     B：int minValue=0;
        int maxValue=array.length-1;
        while ((minValue<=maxValue)){
            int temp=array[minValue];
            array[minValue]=array[maxValue];
            array[maxValue]=temp;
            minValue++;
            maxValue--;
        }
        System.out.println(array.length);
        System.out.println(Arrays.toString(array));
        }
    }
}
2.使用分割数组的方式，将数组分割成前后两部分，只循环前一部分，当循环到中间元素时，停止循环
	
public class ArrayTurnAroundDemo {
    public static void main(String[] args) {
        int[] array=new int[]{12,4,6,7,2,76,45,2,782,3};
     	for(int i=0;i<array.length/2;i++){
	         int temp=array[i];
	         array[i]=array[array.length-1-i];
	         array[array.length-1-i]=temp;
     }
        System.out.println(Arrays.toString(array));
    }
}

1.11 查询数组中某个值第一次出现的位置

public class ArrayNumberFirstLocation {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要查询的数据");
        int value=scanner.nextInt();
        int[]   array=new int[]{1,34,65,356,146,6551,624};
        ArrayNumberFirstLocation arrayNumberFirstLocation=new ArrayNumberFirstLocation();
        int num=arrayNumberFirstLocation.indexof(array,value);
        System.out.println(num);

}
    public static int  indexof(int[] array,int value){
        for (int i=0;i<array.length;i++){
        if(array[i]==value){
            System.out.println(value+"第一次出现的位置是"+(i+1));
            //寻找第一次的位置，找到之后停止循环，不进行第二位置的查找
            return i;
        }
        }
        return -1;
   }
}

1.12 冒泡排序

//键盘录⼊5个学⽣的年龄, 按照从⼤到⼩对年龄进⾏排序
public class Test01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[] array=new int[5];
        for(int i=0;i<array.length;i++){
            System.out.println("请输入学生成绩：");
            array[i]=scanner.nextInt();
        }
        for(int i=1;i<array.length;i++){
            for(int j=0;j<array.length-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
        scanner.close();
    }
}

1.13 JDK排序

	int[] array={1,34,5,4,34,6,34,45};

 1.sort方法
 
        Arrays.sort(array);
   2.sort(int[] array, int fromIndex,int toIndex)//排序数组指定区间的元素，取头不取尾
   
   //排序数组的从0到4位元素,排a[0],a[1],a[2],a[3];
   
      Arrays.sort(array,0,4)  ;   
        
  2.toString方法
  
        System.out.println(Arrays.toString(array));

1.14 JDK方法测试

//在歌唱⽐赛中,共有10位评委进⾏打分,在计算歌⼿得分时,去掉⼀个最⾼分,去掉⼀个最低分, 然后剩余的8位评
//委的分数进⾏平均,就是该选⼿的最终得分.输⼊每个评委的评分,求某选⼿的得分
public class SongerScore {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int[] array=new int[10];
        int sum=0;
        for(int i=0;i<array.length;i++){
            System.out.println("请输入第"+(i+1)+"个成绩：");
            array[i]=scanner.nextInt();
        }
        //排序
        Arrays.sort(array);
        //最大最小值设置为0
        array[0]=0;
        array[9]=0;
        //求和
        for(int i=0;i<array.length;i++){
            sum+=array[i];
        }
        System.out.println("平均成绩是："+sum/8);
        scanner.close();
    }
}