day04

数组

产生随机数：
Random的使用
1.导包
·import java.util.Random;
2.创建对象
·Random r=new Random();
3.获取随机数
·int number=r.nextlnt(10);

import java.util.Random;//导包
public class Test03_02{
    public static void main(String[] args) {
        Random r = new Random();//创建对象
        for (int i = 10; i > 0; i--) {
                int number = r.nextInt(10);//获取随机数
                System.out.println("number:" + number);
        }
        System.out.println("-------------------");
        for (int j= 0; j < 100; j++) {
            int i = r.nextInt(100) + 1;//不加1去不到100
            System.out.println("i:" + i);
        }
    }
    }

import java.util.Random;
public class Test02_random {
   public static void main(String[] args) {
       Random r=new Random();
       int number=r.nextInt(100)+1;
       while (true){
           Scanner sc=new Scanner(System.in);
           System.out.println("请输入你要猜的数字（0-100):");
           int guessNuber=sc.nextInt();
           if (guessNuber>number){
               System.out.println("你猜的数字"+guessNuber+"太大了");
           }
           else if(guessNuber<number){
               System.out.println("你猜的数字"+guessNuber+"太小了");
           }
           else {
               System.out.println("恭喜你猜对了"+guessNuber);
           break;
           }
       }
   }
}

数组：一种容器，可以存放多个数据值（数据类型必须统一）。
特点：
数组时一种引用类型，数组的长度在程序运行期间不可改变。
格式定义：
动态初始化：
数据类型[] 数组名称=new 数组类型[数组长度]；
可以分成两步骤:

int   arrayA;
arrayA=new   int[5];

静态初始化：
数据类型[] 数据名称=new 数据类型[]{元素1，元素2}
可以分成两步骤:

int   arrayA;
arrayA=new   int[]{1，2，3}；

省略格式：
数据类型[] 数组名称={元素1，元素2，}
注意事项：
静态初始化没有指定长度但是会自动推算得到长度。
静态初始化的省略格式不能分成两步写。
java的内存划分为5个部分：
1.栈：存放的都是方法中的局部变量。方法一定时在栈当中运行的。作用域：一旦超出了作用域，立刻从站内存当中消失。
2.堆:凡是new出啦的东西都在堆当中。堆里面都有一个地址值（16进制），对内存里面的数据都有一个默认值。

3.方法区：存储class相关的信息，包含方法信息。
4.本地方法栈：与操作系统相关。
5.寄存器：与cpu相关。


数组的索引越界：

根本原因时数组元素长度个数写错了。
空指针问题：
所有的引用类型变量，都可以赋值一个null值。但代表其中什么都没有。


数组的遍历:

public class Demo04 {
    public static void main(String[] args) {
        int [] array={10,20,30,5,15,14,36,};
        for (int i = 0; i <= array.length-1; i++) {
            System.out.println(array[i]);
        }
    }

求出数组当中的最大值：

 public static void main(String[] args) {
        int [] arrary={5,25,4,5,4,5,6,9,63,87,};
        int max=arrary[0];
        for (int i = 1; i < arrary.length; i++) {
           if(arrary[i]>max){
               max=arrary[i];
           }
        }
        System.out.println("最大值："+max);
    }
        }

数组反转：

 public static void main(String[] args) {
      int [] arrary={5,25,4,5,4,5,6,9,63,87,};
  for(int min=0,max=arrary.length-1;min<max;min++,max--){
      int temp=arrary[min];
      arrary[min]=arrary[max];
      arrary[max]=temp;
  }
      for (int i = 0; i < arrary.length; i++) {
          System.out.println(arrary[i]);
      }
  }
      }
      ```
数组作为方法的返回值：
public class Demo02ArrayReturn {
  public static void main(String[] args) {
      int[] result = calculate(10, 20, 30);
      System.out.println("main方法接收到的返回值数组是：");
      System.out.println(result); // 地址值
      System.out.println("总和：" + result[0]);
      System.out.println("平均数：" + result[1]);
  }

  public static int[] calculate(int a, int b, int c) {
      int sum = a + b + c; // 总和
      int avg = sum / 3; // 平均数
      // 两个结果都希望进行返回

      // 需要一个数组，也就是一个塑料兜，数组可以保存多个结果
      /*
      int[] array = new int[2];
      array[0] = sum; // 总和
      array[1] = avg; // 平均数
      */
      int[] array = { sum, avg };
      System.out.println("calculate方法内部数组是：");
      System.out.println(array); // 地址值
      return array;
  }
}

二维数组：
格式：
数据类型[][] 数组名；
初始化：
动态初始化：
数据类型[][]数组名=new 数据类型[m]][n];
m表示二维数组的个数，n表示的是一维数组的元素个数。
静态初始化：
数据类型[][] 数组名=new 数据类型[]][]{{元素···}，{元素}，{元素}}；
简化格式：
数据类型[]][] 数组名={{元素}，{元素}，{元素}，{元素}}；

package cn.itcast.day04.demo02;
public class arraryTest {
    public static void main(String[] args) {
        int count = 0;
        int[][] arr = {{1, 2, 3}, {4, 5, 6,}, {11, 1, 22}};
        for (int i = 0; i < arr.length; i++) {
            for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.print(arr[i] [i1]+" ");
                count++;
                if (count % 3 == 0) {
                    System.out.println();
                }
            }
        }
    }

结果