随机数（Ranom）

1,作用：产生一个随机数

2,使用步骤： (1)导包：importjava.util.Random (2)创建对象：Random r=new Random(); (3)获取随机数：int number = r.nextInt(100);

*注意点:产生的数据在0到100之间，含头不含尾[0,100)。如果我们想要产生一个30~59 ，45~99这样的数。我们就可以利用（A-B）+B+1;列如(59-30)+30+1随机产生式30 ~59，列如(99-45)+45+1随机产生式45 ~99。

4,练习

package com.baidu.Demo;
import java.util.Random;//随机数
public class DemoRandom {
    public static void main(String[] args) {
        Random r=new Random();
        int number=r.nextInt(100);
        int number2=r.nextInt(59-30)+30+1;
        int number3=r.nextInt(99-45)+45+1;
        System.out.println(number);
        System.out.println(number2);
        System.out.println(number3);
    }
}

5,和Scanner方式类似，我觉得Java这个导包就好比C语言中的头文件。

数组概述

1,数组的概念

数组是存储同一种数据类型多个元素的容器。数组既可以存储基本数据类型，也可以存储引用数据类型。

2,数组定义格式

(1)数据类型[] 数组名,int[] arr; 定义了一个int类型的数组，数组名为arr

(2)数据类型数组名[],int arr[];定义了一个int类型的变量，变量名是arr数组

3,数组的初始化

(1)动态初始化：初始化时只指定数组长度。由系统为数组分配初始化值。

(2)静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

*注意点:Java中的数组必须先初始化,然后才能使用（就是为数组中的数组元素分配内存空间，并为每个数组元素赋值）

4,动态初始化

(1)格式：数据类型[] 数组名 = new 数据类型[数组长度];int[] arr = new int[4];

(2)数组长度其实就是数组中元素的个数。

(3)解释：定义了一个int类型的数组，这个数组中可以存放4个int类型的值。 *注意:数组索引越界和空指针异常问题

5,练习

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr = new int[4];
        System.out.println(arr);//[I@26d607
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0
        System.out.println(arr[3]);//0
    }
}

内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈存储局部变量 堆存储new出来的东西 方法区 (面向对象)

内存图解

1,定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int [] arr=new int[4];
        arr[0]=1;
        arr[1]=2;
        System.out.println(arr);//打印地址
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
}

2,定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr=new int[3];
        arr[0]=1;
        arr[1]=2;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println("-------------------------------------");
        int[] arr1=new int[3];
        arr1[0]=3;
        arr1[1]=4;
        arr1[2]=5;
        System.out.println(arr1);//打印地址
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}

3,定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr = new int[2];
        arr[0] = 3;
        arr[1] = 4;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        int[] arr2 = arr;
        arr2[0] = 1;
        arr2[1] = 2;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
    }
}

数组初始化

1, 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

2,格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…}; int[] arr = new int[]{1,2,3};定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3，也可以写成int[] arr = {1,2,3};

3,内存图解

4,数组遍历(依次输出数组中的每一个元素) 获取数值长度：数值名.length

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr={1,2,3,78,2,8,9,8,52,79,10};
        for (int i = 0; i <11 ; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("该数组的长度");
        System.out.println(arr.length);
    }
}

二维数组

1,二维数组定义格式：数据类型[][] 数组名;

2.初始化方式 (1)数据类型[][] 变量名 = new 数据类型[m][n];

(2)数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

(3)简化格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}}

3,二维数组遍历例:int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                System.out.print(arr[i][j]);
            }
            System.out.println();//换行
        }
    }
}

数组反转

1,数组的反转：数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

2,方法一：直接逆序遍历

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
       for (int i = arr.length-1; i >=0 ; i--) {
            System.out.print(arr[i]+" ");
        }
    }
}

3,方法二

(1)思想：数组中最后面的的元素和最前面的元素互换位置。

a,定义两个变量，保存数组的最小索引和最大索引 b,两个索引上的元素交换位置 c,最小索引++，最大索引–，再次交换位置 d,最小索引超过了最大索引，数组反转操作结束

package com.baidu.Demo;
public class DemoArray {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
        int temp=0;
        for (int min=0,max=arr.length-1;min<max;min++,max--) {
            temp=arr[min];
            arr[min]=arr[max];
            arr[max]=temp;
        }
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

方法二让我想到了C语言的快速排序。

注意点

数组使用前先初始化,数组索引越界和空指针异常问题 栈区:存储局部变量。堆区:存储new出来的东西。方法区 :(面向对象)

所有巧合的是要么是上天注定要么是一个人偷偷的在努力。

结束！

// END

（建议收藏）Java基础知识笔记二（详细）