Day7 一.1数组的概述1.2 数组的概念 二.2.1 动态初始化的格式2.2 静态初始化的格式 三. 数组的遍历 四数组应用案例

 一.  数组的概述

 1.1  为什么要有数组（容器）

​        为了存储同种数据类型的多个值

 1.2  数组的概念

​        数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器

 二.  数组的初始化

数组的初始化：就是为数组开辟连续的内存空间，并为数组的每个元素赋值

 2.1 动态初始化的格式

​        数据类型[] 数组名 = new 数据类型[数组长度];

动态初始化，只指定长度，由系统给出初始化值

​        int[] arr = new int[10];

 2.2  静态初始化的格式 

​        数据类型[] 数组名 = new 数据类型[]{元素1，元素2，……};

​        简化格式：

​                    数据类型[] 数组名 ={元素1，元素2，……};

 三. 数组的遍历

数组遍历：就是依次输出数组中的每个元素

数组的属性：arr.length数组的长度

数组的最大索引：length-1

练习：分别创建存储一组姓名的数组、一组字符的数组、一组数字的数组。

​        要求：写一个方法专门用来遍历数组

 四. 数组应用案例

4.3  数组的反转

int[] arr = {53,67,34,6,724,8,0};  //7个  长度n   11/2   100

反转

arr = {0,8,724,6,34,67,53};

交换3（n/2）遍 ----->循环

      arr[0]    arr[6]

      arr[1]    arr[5]

      arr[2]    arr[4]

      arr[i]    arr[6-i]

核心：两个数据交换

int a = 9;

int b = 20;

int c = a ;//临时变量  c=9

a = b;     //a = 20

b = c;     //b = 9

4.4  数组的排序

int[] arr = {53,67,34,6,724,8,0};

//核心：相邻的两个数之间判断大小，交换

工具类： jdk 很多的系统类  开发文档API  会用   Scanner扫描器类

Arrays更加方便数组的运用

排序  sort()

查找

java数据类型分两类：

    基本数据类型  byte short int long float double char boolean 8个

    引用数据类型  数组、类、接口、String系统类

int a = 10;

int[] b = {12,4,5};

public class Arr_Demo1 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //案例   存储一组数字   int
        //int a = 10;
        //数组的初始化 ：  指定数组长度和类型，计算机开辟内存空间，默认值0
        //动态初始化
        int[] arr1 = new int[20];//20是数组的长度，可以允许放20个int类型的元素
        //存储具体的数字 向第一个空间来存储99   编号（下标、索引）
        arr1[0]  = 99;
        System.out.println("输入整数");
        arr1[1] = sc.nextInt();
        arr1[2]  = 90;
        arr1[2]  = 100;
        //....Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
        arr1[19] = 9;//下标越界  超过数组长度
        //int[] arr2 = new int[]{2,5,12,54,6,247,6,78};

        //静态初始化
        int[] arr3 = {2,5,12,54,6,247,6,78}; //{}元素有多少个，数组的长度就是多少
        arr3[0] = 20;//修改值  赋值
    }

public class Arr_Demo2 {
    public static void main(String[] args) {
        //2. 如何向数组中存储一组数据     如何通过键盘录入
        //字符串数组  String[]   存储 50个一组姓名，自己输入
        Scanner sc = new Scanner(System.in);

        //创建字符串数组
        String[] nameArr = new String[5];
        //循环50遍  0  49、
        for (int i = 0; i < nameArr.length ; i++) { //5  数组的长度   nameArr.length
            System.out.println((i+1)+".姓名：");
            nameArr[i] = sc.next();//将字符串 存储在数组中的每一个下标对应的位置
        }

        //输出其中的数据   输出最后一个人的姓名
        System.out.println("最后一个："+ nameArr[nameArr.length -1] );//4
        //输出最前面的人的姓名
        System.out.println("第一个："+nameArr[0]);

    }
}

public class Arr_Demo3 {

    public static void main(String[] args) {
        //3. 数组遍历（把数组中所有的值全部输出）
        int[] arr1 = {13,75,5,3,-1,-56};
        int[] arr2 = {913,375,52,321,-11,-156};
        int[] arr3 = {13,75,665,3,-11,-56};

      /*  for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("----------------------");
        //反向遍历
        for (int i = arr.length-1; i >= 0; i--) {
            System.out.println(arr[i]);
        }*/
        printArr(arr1);
        printArr(arr2);
        printArr(arr3);

        String[] arr4 = {"35","abc","hello","java"};
        printArr(arr4);
    }
    //独立的方法   ---->目的  遍历整数数组
    public static void printArr(int[] arr){//参数：是一个数组
        System.out.println("--------------");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
    }
    public static void printArr(String[] arr){//参数：是一个数组
        System.out.println("--------------");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
    }

}

public class Arr_Demo4 {

    public static void main(String[] args) {
        //4.1  求最大值
        /*
        1. 创建变量max 存储最大值  int max = 第一个值;
        2. 与后面的值依次比较，写循环 初始值1 ---arr.length
        3. 如果后面的数字比max还要大，  max = 后面较大的值;
        4. 循环完全结果， 输出max
         */

        //4.1  求最小值
        /*
        1. 创建变量min 存储最小值  int min = 第一个值;
        2. 与后面的值依次比较，写循环 初始值1 ---arr.length
        3. 如果后面的数字比min还要小，  min = 后面较小的值;
        4. 循环完全结果， 输出min
         */
        int[] arr = {9,375,1512,321,1000,-11,-156};

        int max = arr[0];//临时保存第一个数，认为它是暂时最大的值
        int min = arr[0];

        for (int i = 1; i < arr.length; i++) {//i  后面数据的下标  arr[i] 数组中的值
            if(arr[i]    > max ){
                max = arr[i];
            }
            if(arr[i] < min){
                min = arr[i];
            }
        }
        System.out.println(max);
        System.out.println(min);
    }
}

public class Arr_Demo5 {

    public static void main(String[] args) {
        //4.2  求某元素第一次出现的索引（下标、位置）  查找
        //1. 创建变量 保存位置  int index  = -1;//假设 最坏的情况最假设 假设它不存在
        //2. 循环比较 是否相等
        //3. 相等，直接输出当前的索引
        // int[] arr = {9,375,1512,321,1000,-11,-156};  查1000
        Scanner sc = new Scanner(System.in);
        System.out.println("输入你要查找的数字：");
        int number = sc.nextInt();
        int[] arr = {9,375,1512,321,1000,-11,-156};
        int index = -1;
        for (int i = 0; i <arr.length ; i++) {
            if(number  == arr[i]){//arr[i]每一个数字
                 //保存
                index = i;
                break;//提前退出循环
            }
        }
        //根据索引的值  判断这个数是否存在数组中  只要不等于-1 存储   ==-1 不存在
        if(index == -1){
            System.out.println("这个数据不存在！");
        }else{
            System.out.println("这个数据存在，索引为："+index);
        }
    }
}

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入正方形边长：");
        int a=sc.nextInt();
        are(a);
        System.out.println("请输入长方形长：");
        int a1=sc.nextInt();
        System.out.println("请输入长方形宽：");
        int a2=sc.nextInt();
        are(a1,a2);
        System.out.println("长方形的面积是："+are(a1,a2));
    }
    public static void are (int a){
        int are=a*a;
        System.out.println("正方形的面积是："+are);
    }
    public static int are (int a,int b){
        int are=a*b;
        return are;

    }
}

public class Demo2_2 {

    public static void main(String[] args) {
        int sheng = waimai(100,10);//只要方法有返回值，通过变量来接收这个值
        //剩下的钱去买东西
        sheng = waimai(sheng  ,50);
        System.out.println("main:"+sheng);
    }
    //买东西  钱 money,  买的这个东西的价格price
    public static int waimai(int money,int price){
        int sheng = money;
        //判断
        if(money >= price){
            sheng = sheng - price;
            System.out.println("购买成功,还剩："+sheng);
        }else{
            System.out.println("不够");
        }
        //最后返回一个值  一旦写了返回值return  ,void就要修改成对应的数据类型
        return sheng;
    }
}

import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        double x=sc.nextDouble();
        System.out.println("请输入第二个数字：");
        double y=sc.nextDouble();
        System.out.println("请输入第三个数字：");
        double z=sc.nextDouble();
       double m =  mimn(x,y,z);
       double n = pjz(x,y,z);
       System.out.println("这三个数的平均值与最小值的差是："+(m-n));
    }

    public static double mimn(double a,double b,double c){
        if(a<b&&a<c){
            System.out.println("最小值是："+a);
           return a;
        }else if(b<a&&b<c){
           System.out.println("最小值是："+b);
            return b;
        }else System.out.println("最小值是："+c);
        return c;
    }
    public static double pjz(double a,double b,double c){
        double pjz=(a+b+c)/3;
        System.out.println("平均值是："+pjz);
        return pjz;
    }
}

public class Demo04 {

    public static void main(String[] args) {
        add(11,55);
        add(1.1,2.3,4.2);
        add(1,5,3);
    }

    //求和  2个整数
    public static int add(int x,int y){
        int sum = x+y;
        System.out.println(sum);
        return sum;
    }

    //求和  3个小数
    public static double add(double x,double y,double z){
        double sum = x+y+z;
        System.out.println(sum);
        return sum;
    }
    //求和  3个整数
    public static int add(int x,int y,int z){
        int sum = x+y+z;
        System.out.println(sum);
        return sum;
    }
}

05.01_Java 语言基础（数组概述和定义格式说明）（了解）

A ：为什么要有数组（容器）

为了存储同种数据类型的多个值

B ：数组概念

数组是存储同一种数据类型多个元素的集合，也可以看成是一个容器

数组既可以存储基本数据类型，也可以存储引用数据类型（面向对象时讲）

C ：数组定义格式

数据类型 [] 数组名 = new 数据类型 [ 数组的长度 ] ；

05.02_Java 语言基础（数组的初始化动态初始化）（掌握）

A ：什么是数组的初始化

就是为数组开辟连续的内存空间，并为数组的每个元素赋值

B ：如何对象数组进行初始化

a: 动态初始化，只指定长度，由系统给出初始化值

int[] arr = new int[10];

b: 静态初始化，给出初始化值，由系统决定长度

C ：动态初始化的格式：

数据类型 [] 数据名 = new 数据类型 [ 数组长度 ] ，就是定义数组的格式

05.03_Java 语言基础（ java 中内存分配及栈和堆的区别）（掌握）

A ：栈：存储局部变量

局部变量：定义在方法里的变量

B ：堆：存储 new 出来的数组或对象

C ：方法区：面向对象部分讲解

public class Demo9 {
 public static void main(String[] args) {
 int[]a = new int[3];
 System.out.println(a);//[I@10f87f48
 /*
 [I@10f87f48
 [ :代表一位数组
 I ：代表 int 类型
 @ ：就是@符号
 10f87f48 ：是一个十六进制的整数
 */
 System.out.println(a[0]);
 System.out.println(a[1]);
 System.out.println(a[2]);
 System.out.println("---------------");
 a[1] = 3;
 a[2] = 4;
 System.out.println(a[0]);
 System.out.println(a[1]);
 System.out.println(a[2]);
}
}

 数组内存图解 3：三个引用两个数组

public class Demo9 {
 public static void main(String[] args) {
 int[] a = new int[3];
 System.out.println(a[1]);
 System.out.println(a[2]);
 System.out.println("数组 a 的内存地址："+a);
 double[] b = new double[10];
 System.out.println(b[0]);
 System.out.println(b[1]);
 System.out.println(b[2]);
 int[] c = a;
 System.out.println("数组 c 的内存地址："+c);
 System.out.println("a[0]="+a[0]);
 c[0] = 20;
 System.out.println("c[0]="+c[0]);
 System.out.println("a[0]="+a[0]);
 } }
/*
各数据类型的默认值
byte\short\int\long：0
float:0.0f;
double:0.0
boolean:false
char:'\0000' =0 char 是两个字节： 0000 0000 0000 0000 十六进制是二进制的四位合并为一位：0000=0
String：null
*/

 

05_Java 语言基础（静态初始化的格式）（掌握）

A ：静态初始化的格式：

格式：数据类型 [] 数组名 = new 数据类型 []{ 元素 1 ，元素 2 ，…… }

简化格式：

数据类型 [] 数组名 ={ 元素 1 ，元素 2 ，…… }

B ：案列演示

对数组的解释

输出数组名称和数组元素

C ：画图演示

public class Demo10 {
 public static void main(String[] args) {
 //静态初始化
 //方式一
 int[] a1 = new int[]{10,20,30,40,50};
 System.out.println(a1[0]);
 System.out.println(a1[1]);
 System.out.println(a1[2]);
 System.out.println(a1[3]);
 System.out.println(a1[4]);
 System.out.println("--------------");
 //方式二：
 int[]a2 = {12,23,34,45,56}; //开发中推荐这么写
 System.out.println(a2[0]);
 System.out.println(a2[1]);
 System.out.println(a2[2]);
 System.out.println(a2[3]);
System.out.println(a2[4]);
 } }

 05_Java 语言基础（数组操作的两个常见小问题：越界和空指针）（掌握）

public class Demo10 {
 public static void main(String[] args) {
 int[]a = {12,23,34,45,56}; //开发中推荐这么写
// System.out.println(a[10]);//ArrayIndexOutOfBoundsException:
 // 数组 索引 越界 异常
 a = null;
 System.out.println(a[0]);//java.lang.NullPointerException
 // 空指针 异常
 }

 

05_Java 语言基础（数组遍历）（掌握）

案例演示：

数组遍历：就是依次输出数组中的每个元素

数组的属性： arr.length 数组的长度

数组的最大索引： length-1

public class Demo10 {
 public static void main(String[] args) {
 int[]a = {12,23,34,45,56,67,78,89};
 /* System.out.println(a[0]);
 System.out.println(a[1]);
 System.out.println(a[2]);
 System.out.println(a[3]);
 System.out.println(a[4]);
 System.out.println(a[5]);
 System.out.println(a[6]);
 System.out.println(a[7]);*/
 for(int i=0;i<8;i++){
 System.out.print(a[i]+"\t");
 }
 System.out.print("\n");
 int len = a.length;//可以获取数组的长度
 System.out.println("数组的长度="+len);
 for(int i=0;i<a.length;i++){
 System.out.print(a[i]+"\t");
 }
 System.out.println();
 System.out.println("---------------------");
 //while 循环遍历数组
 int n=0;
 while(n<a.length){System.out.println(a[n]);
 n++;
 }
 } }

练习：

写一个方法专门用来遍历数组

public class Demo11 {
 public static void main(String[] args) {
 int[]a = {20,30,40,50,60,70,80};
 printArray(a);
 }
 //遍历数组的方法
 public static void printArray(int[]arr){ //等同于 int[]arr = {20,30,40,50,60,70,80}
 for(int i=0;i<arr.length;i++){
 System.out.print(arr[i]+"\t");
 }
 } }