Day7 数组及其简单应用

数组

数组是相同类型数据的有序集合.
相同类型的若干个数据,按照一定先后次序排列组合而成。
其中,每一个数据称作一个数组元素
每个数组元素可以通过一个下标来访问它们.

数组特点:
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组是引用类型，字符串底层实现是数组。

定义

如何定义？
数据类型[] 数组名字 ;
double []socres;
数据类型 数组名字[] ;
double scores[];

数组分配内存？
内存空间： 栈区、堆区、方法区
double []scores = new dobule[5];

如何获取数组中元素的个数？
scores.length
如何打印数组中的具体值？ (索引值,下标值)
下标值: 0 ~ socres.length-1;
scores[0] = sc.nextDouble();

数组的创建与使用：

import java.util.*;
public class  ArrayTest{
    public static void main(String[] args){
        //int [] score={1,2,3};
        //int score[]={1,2,3};
        Scanner sc=new Scanner(System.in);
        int [] score=new int[5];

        System.out.println("请输入5个数字");
        score[0]=sc.nextInt();
        score[1]=sc.nextInt();
        score[2]=sc.nextInt();
        score[3]=sc.nextInt();
        score[4]=sc.nextInt();
        System.out.println(score[1]+"\t"+score[2]);
    }
}

例题：

1.从键盘录入5个学生分数，求总分，平均分，分别打印
1、循环
2、扫描器
3、求总分，平均分

import java.util.*;
public class Test3{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int sum=0;
        int ave=0;
        int count=5;
        int[] score=new int[count];
        for(int i=0;i<score.length;i++){
            System.out.println("请输入第"+(i+1)+"个学生的分数:");
            score[i]=sc.nextInt();
            sum+=score[i];
        }
        ave=sum/count;
        System.out.println("学生的总分是："+sum+"平均分是："+ave);

    }
}

2.从键盘录入任意5个整型值，找出中间的最大值
1.Scanner
2.int []numbers
3.int max

import java.util.Scanner;
public class TestArray3{
    public static void main(String[]args){
        //创建扫描器
        Scanner sc = new Scanner(System.in);
        //定义可以存储5个整型值的数组
        int[]numbers = new int[5];
        for(int i = 0;i < numbers.length;i++){
            System.out.println("请输入numbers["+i+"]的值");
            //将键盘录入的值，存储到数组中对应的索引位置出
            numbers[i] = sc.nextInt();
        }
        System.out.println("数组numbers中的最大值为:"+getMaxValue(numbers));
        System.out.println("数组numbers中的最大值为:"+numbers[getMaxIndex(numbers)]);
    }
    /**
    作用  :找出数组中的最大值
    参数  :array 目标数组
    return  : int  返回数组中的最大元素值
    */
    public static int getMaxValue(int []array){
        int max = array[0];
        for(int i = 1;i < array.length;i++){
            if(max < array[i]){
                max = array[i];
            }
        }
        return max;
    }
    /**
    作用  :找出数组中的最大值对应的索引值
    参数  :array 目标数组
    return  : int  返回数组中的最大元素的索引值
    */
    public static int getMaxIndex(int[]array){
        int index = 0;
        for(int i = 1;i < array.length;i++){
            if(array[index] < array[i]){
                index = i;
            }
        }
        return index;
    }

}

双色球问题：

购买一注双色球彩票
红+蓝
6+1
红球：不能重复，1~33的区间
蓝球：1~16
蓝球号码跟红球号码可以重复

import java.util.Scanner;
public class TestArray6{
    public static void main(String[]args){
        //记录球的个数
        int count = 7;
        //用来存储选择的号码
        int []lottery = new int[count];
        //创建扫描器
    Scanner sc = new Scanner(System.in);
    for(int i = 0;i < lottery.length;i++){
        if(i < lottery.length - 1){
                System.out.println("请输入第"+(i+1)+"个红球号码");
                //lottery[i] = sc.nextInt();
        int temp = sc.nextInt();
    if(temp > 0 && temp <= 33){
                    //判断数组中是否已经选择了号码temp，如果没有选，再进行赋值
                    if(isContain(lottery,temp)){
                        System.out.println("号码重复,重新选择");
                        i--;
                    }else{
                        lottery[i] = temp;
                    }
                }else{
                    System.out.println("选择号码有误，请重新选择");
                    //
                    i--;
                }
            }else{
                System.out.println("请输入蓝球号码");
                int temp = sc.nextInt();
                if(temp > 0 && temp <= 16){
                    lottery[i] = temp;
                }else{
                    System.out.println("选择号码有误，请重新选择");
                    i--;
                }
            }
        }
        showLottery(lottery);
    }
    /**
    判断数组array中是否包含元素num
    如果包含返回true，如果没有返回false
    */
    public static boolean isContain(int[]array,int num){
        boolean result = false;
        for(int i = 0;i < array.length;i++){
            if(array[i] == num){
                result = true;
                break;
            }
        }
        return result;
    }
    /**
    展示数组array中所有的元素
    */
    public static void showLottery(int[]array){
        /* for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+" ");
        } 
        System.out.println("~~~~~~~~傲娇的分割线-----"); */
        //for-each循环
        for(int a: array){
            System.out.print(a+" ");
        }
    }
}

数组的初始化方式：

静态初始化

除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。
int[] a = {1,2,3};
Man[] mans = {
new Man(1,1),
new Man(2,2)
};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] a = new int[2];
a[0]=1;
a[1]=2;
A int a[]={1,2,3,4}; 正确
B. int b[4]={1,2,3,4}; 错误
C. int c[];c={1,2,3,4}; 错误
D. int d[];d=new int[]{1,2,3,4}; 正确

数组的默认初始化：

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int a[] = new int[2]; //0,0
boolean [] b = new boolean[2]; //false,false
String[] s = new String[2]; //null, null

数组的界限

每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)；
数组的长度: 数组名.length

起点和终点
起点: 数组名[0]
终点: 数组名[length-1]

for-each循环

    for(int a: array){            遍历数组array，让数组里的每一个元素赋值给a.
        System.out.print(a+" ");
    }
    等价于--
    for(int i = 0;i < array.length;i++){
        System.out.print(array[i]+" ");
    } 

Arrays工具类

API文档查看
工具类: Arrays
java.util.Arrays
比如排序和搜索
排序：Arrays.sort(数组名)

搜索：Arrays.binarySearch(arr,90) 搜索数组名字为arr，元素为90,搜索返回的是一个索引值。
在搜索之前必须要排序。

打印 一维数组 ：转换为字符串： Arrays.toString(数组名)
打印 二维数组 ：Arrays.deepToString(数组名)

数组比较是否相等： equals(数组1，数组2).
如果两个指定的 int 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，
并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。
换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
此外，如果两个数组引用都为 null，则认为它们是相等的。

数组的复制： Arrays.copyOfRange(数组名,起始下标,终止下标) Arrays.copyOfRange(arr,0,2)
包括下标为0的元素但不包括下标为2的元素。

数组的填充：Arrays.fill(数组名，用什么数字填充)

例题

1.二分搜索：

import java.util.*;
public class Test4{
    public static void main(String[] args){
        //二分搜索
        int[] arr={1,3,6,5,7};
        //System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        Arrays.binarySearch(arr,6);
        System.out.println(Arrays.toString(arr));
        int[] arr2=Arrays.copyOfRange(arr,0,4);
        System.out.println(Arrays.toString(arr2));
        //Arrays.fill(arr2,1);
        //System.out.println(Arrays.toString(arr2));
        boolean result=true;
        if(Arrays.equals(arr,arr2)){
            System.out.println("相等");
        }
        else{
            System.out.println("不相等");
        }


    }
}

2.数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；
然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，
包含这个单词就打印出“Yes”，不包含就打印出“No”。
声明并赋值一个字符数组时候，里面的字符元素要”.
声明并赋值一个字符串数组时候，里面的字符元素要”“.
查找一个数组里有没有一个字符串的时候用数组搜索。

import java.util.Scanner;
import java.util.Arrays;
public class HomeWork{
    public static void main(String[] args){
        String[] arr={"AAA","BBB","CCC","DDD","EEE","FFF","GGG","HHH","III","JJJ"};
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符：");
        String str=sc.next();
        Arrays.sort(arr);
        int index = Arrays.binarySearch(arr,str);
        if(index>=0)
        {
            System.out.println("Yes");
        }
        else{
            System.out.println("No");
        }

    }
}

3.获取数组最大值和最小值操作：利用Java的Math类的random()方法，
编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数
，并统计其中>=60的有多少个。
提示：使用 int num=(int)(n*Math.random());获取随机数

public class HomeWork2{
public static void main(String[] args){
     int num=0;
     int [] arr=new int[50];
     int count=0;
     for(int i=0;i<50;i++){
        num=(int)(100*Math.random());
        arr[i]=num;
     }
    int m=isMaxValue(arr);
    int n=isMinValue(arr);
    int q=great(arr);
    System.out.println("最大值是："+m);
    System.out.println("最小值是："+n);
    System.out.println("大于60的个数为："+q);

}
public static int isMaxValue(int num[]){
        int max=num[0];
       for(int i=0;i<num.length;i++){
        if(max<num[i]){
            max=num[i];
       }
       }
       return max;

    }
    public static int isMinValue(int num[]){
        int min=num[0];
       for(int i=1;i<num.length;i++){
        if(min>num[i]){
            min=num[i];
       }
       }
       return min;

    }
    //输出大于60元素的个数
    public static int great(int num[]){
        int count=0;
        for(int i=1;i<num.length;i++){
            if(num[i]>60){
                count++;
            }
        }
        return count;
    }
}

4.数组逆序操作：定义长度为10的数组，将数组元素对调，
并输出对调前后的结果。
思路：把0索引和arr.length-1的元素交换，
把1索引和arr.length-2的元素交换…..
只要交换到arr.length/2的时候即可。

public class HomeWork3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 3.数组逆序操作：定义长度为10的数组，将数组元素对调，
        // 并输出对调前后的结果。
        // 思路：把0索引和arr.length-1的元素交换，
        // 把1索引和arr.length-2的元素交换…..
        // 只要交换到arr.length/2的时候即可。

        int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        System.out.println("对调前的数组：" + Arrays.toString(arr));
        Dichotomy(arr);

        System.out.println("对调后的数组：" + Arrays.toString(arr));
    }
    //二分法，查找并对调。
    public static void Dichotomy(int num[]){
        for (int i = 0; i < num.length/2; i++) {
            int temp=num[i];
            num[i]=num[num.length-1-i];
            num[num.length-1-i]=temp;
        }
    }

}

小结

一维数组入门
数组的特点：长度固定，连续空间，存储同一种类型数据
数组内存分配图
for-each循环：简单、主要用于遍历操作

一维数组的应用
数组优缺点
优点：按照索引查询效率高
缺点：添加删除元素效率低；按照内容查询效率低（无序）
冒泡排序：基本的排序算法，理解排序规则，实现并完善排序代码
数组类型做形参
数组的增删查改入门