第四课-Java数组基础及高级使用

数组

  概念：变量储存一个值。数组可以储存多个同类型的值
      定义：数据类型[] 数组名;
      数据类型限制了该数组中的元素的数据类型，比如int[] a;
  赋值(初始化)：必须指定长度
    静态：必须结合定义一起写
        数据类型[] 数组名 = {值1, 值2, ...};
        数据类型[] 数组名 = new 数据类型[]{值1, 值2, ...};
    动态：
        数组名 = new 数据类型[长度];
        通过数组的索引给指定位置赋值
        数组名[索引] = 值1;
        数组名[索引] = 值2;
  长度及索引
    获取长度：数组名.length。注意是属性不是方法
    索引：数组中元素的位置。范围[0, length - 1];
  遍历：使用循环遍历
  数组常见错误
    空指针异常：java.lang.NullPointerException
        经常发生在数组没有被初始化，就直接使用
        如null.属性或方法
    数组索引越界异常：java.lang.ArrayIndexOutOfBoundsException
        数组名[索引]：索引的值超出了范围
    数组元素的默认值
        基本数据类型根据类型的默认值来定
        引用数据的默认为null

练习

1，定义一个方法，实现计算1! + 2! + 3! +…+30!的和，然后打印结果。

2，定义一个由整数组成的数组{1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5}，计算出数组中的奇数个数与偶数个数(0也算偶数)。并打印

3，在将题2中的数组中的非0元素移动一个新的数组中。

4，在题3的新数组中，求出数组的元素和、最大值与最小值，并输出打印

5，产生一个随机数，然后判断该随机数是否属于题3的数组中，如果是，请打印其位置

6，定义一个包含10元素的数组，对其进行赋值，使每个元素的值等于其下标，然后遍历数组，最后将数组倒置(即首尾交换)后再遍历打印

7，给10个老师打分，再找出最高分的那一个老师，将其名称与得分打印

8，定一个长度为30的整数数组，然后随机给每个元素赋值0~9，分别统计0~9这个10个数分别出现的次数。

9，定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中第1个元素的操作

10，在排序好的数组中添加一个数字，将添加后的数字插入到数组合适的位置
11，
(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
 定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。
 练习目的：检验基本数据类型数组创建时的自动赋值。
 (2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。

12. 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，打印出3年级(state值为3）的学生信息。
提示：生成随机数：Math.random()，返回值类型double;  
     四舍五入取整：Math.round(double d)，返回值类型long。

13，定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出出来。

14，使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

Java数学类

Math.PI：圆周率
Math.abs()：求绝对值
Math.random()：产生[0, 1)之间的随机数，类型为double

数组的高级使用

1.求和、求平均数、求最大或最小值、复制、反转

代码示例

    /**
     * 求和
     * */
    public static void sum(){
        int[] array = {1, 3, 5, 7, 9};
        int sum = 0;
        for(int item : array){
            //sum = sum + item;
            sum += item;
        }
        System.out.println("和：" + sum);
    }

    /**
     * 复制
     * */
    public static void copy(){
        int[] array = {1, 3, 5, 7, 9};
        int[] acopy = new int[array.length];
        for(int i = 0; i < array.length; i++){
            acopy[i] = array[i];
        }
    }

    /**
     * 最大值
     * */
    public static void max(){
        int[] array = {1, 3, 5, 7, 9};
        int max = array[0];
        for (int item : array) {
            if(max < item){
                max = item;
            }
        }
        System.out.println("max：" + max);
    }

    /**
     * 反转
     * */
    public static void fanzhuan(){
        int[] array = {1, 3, 5, 7, 9};
        for (int i = 0, j = array.length - 1; i < array.length / 2 && j > array.length / 2; i++, j--) {
            array[i] = array[i] ^ array[j];
            array[j] = array[i] ^ array[j];
            array[i] = array[i] ^ array[j];
        }
        System.out.println(java.util.Arrays.toString(array));;
    }

通过位运算符实现两数交换

    /**
     * 实现两个整型之间交换
     */
    public static void swap(){
        int n = 1;//0001
        int m = 2;//0010
        //^：异或，不一样则为真
        n = n ^ m;//0011
        m = n ^ m;//0001
        n = n ^ m;//0010
    }

Java内存示意图

static关键字的使用

修饰方法：静态方法，该方法可直接在静态方法中调用或通过类名.方法名()调用
修饰属性：调用方式同方法。只有一个内存地址。只要修改一次所有对象的值都改变。

static示例代码

public class StaticDemo {
    private int j = 0;

    public static void main(String[] args) {
        Static s1 = new Static();
        s1.i = 1;
        Static.i = 2;
        System.out.println(Static.i);
        System.out.println(s1.i);
        Static s2 = new Static();
        System.out.println(s2.i);

        //System.out.println(j);

        //System.out.println(this.j)//Cannot use this in a static context
    }

}

class Static{
    public static int i = 0;

    public static void show(){
        System.out.println("Static");
    }

    public static void show(int i){
        System.out.println("Static");
    }

    public void show(int i, int j){
        System.out.println("Static");
    }
}

class SubStatic extends Static{

}

static关键字内存示意图

方法

分类
    构造方法：通过new关键字构造类的对象
    静态方法：被static关键字修饰的方法
        格式：权限修饰符 static 返回值类型 方法名(形参列表){方法体}
            返回值类型
                void：无返回值，方法最后可以省略return;
                数据类型：方法最后必须配合return 数据类型的值;
    实例方法：
        格式：权限修饰符 返回值类型 方法名(形参列表){方法体}
        抽象方法
            格式：权限修饰符 abstract 返回值类型 方法名(形参列表);
                权限修饰符不能为private，该方法是通过子类来实现方法体
        太监方法
            格式：权限修饰符 final 返回值类型 方法名(形参列表){方法体}
            不能被重写。方法重写指的是子类重写父类中的同名方法

数组的排序

1.冒泡排序：两两相邻，彼此交换
2.选择排序：每次选出最小的元素，进行排序
3.插入排序：默认第一个元素为已排序元素，从第二个元素开始插队

示例代码

    /**
     * 冒泡排序
     */
    public static void bubbly(){
        int[] array = {3, 1, 7, 5, 9, 8};
        for(int i = 0; i < array.length - 1; i++){
            for(int j = 0; j < array.length - 1 - i; j++){
                if(array[j] > array[j + 1]){//从小到大
                    array[j] = array[j] ^ array[j + 1];
                    array[j + 1] = array[j] ^ array[j + 1];
                    array[j] = array[j] ^ array[j + 1];
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

视频地址

请大家在第一个博客中寻找。