JAVA基础知识（四）

一.idea的快捷键

自动补全：Ctrl+shift+enter
根据上下文补全：ctrl+shift+space
更改名子：shift+f6
提取变量：ctrl+alt+v
快捷生成方法：alt+insert
抽取一部分形成新的方法：ctrl+alt+m
快速复制方法：ctrl+d
按照层次选择代码：ctrl+w
按照层次取消选择代码：ctrl+shift+w
移动到单词的前面或者后面：ctrl+方向键
光标移动到代码块的前面或者后面：ctrl+【】
上下方法跳跃：alt+上下键
进行代码的折叠：ctrl+<>
快速查找：ctrl+n
文件名称：ctrl+shift+n
任意地方查找：shift+shift
查看当前类的继承关系：ctrl+h
页面关键词查找：ctrl+f（f3上下内容切换）
ctrl +alt+space内容提示
ctrl+alt+L 格式化代码
ctrl+/单行注释
strl+shift+/ 选中代码注释，多行注释，再按取消
alt+enter导抱和自动修正

二.数组

1.数组定义

用来存储多个相同类型的数据的容器。

2.基本格式

格式一： 数据类型[] 变量名；
示列： int[] arr;
格式二： 数据类型 变量名[];
示列： int arr[];
一般使用第一种格式

3.数组的初始化

3.1 栈
在方法中定义的变量，局部变量，方法执行要进栈，程序结束，栈中的方法就消失了。
3.2 堆
凡是new出来的都在堆中，堆中的数据，会被垃圾回收器自动回收。
3.3 数组初始化默认值
整型 ：0
浮点型 ：0.0
字符型 ：空字符
布尔型： false
引用类型：null
3.4 初始化定义
为数组中的元素分配空间然后赋值
3.5动态初始化方式
特点：指定长度
基本格式：数据类型[] 变量名=new 数据类型[数组长度]；
示列：int[] arr=new int[10];
3.6静态初始化方式
特点：指定内容
基本格式：数据类型[] 变量名=new 数据类型[] {数据1,数据2,数据3};
示列：int[] b=new new int[] {1,2,3};
3.7静态初始化简化格式
基本格式：数据类型[] 变量名=数据1,数据2,数据3};
示列：int[] b={1,2,3};

4.元素的访问格式

定义：数组位置的编号
基本格式：数组名[索引]
注意：
数组的索引是从0开始的，连续的，逐1递增的。

5.初始化数组，并输出数组中的元素

5.1代码示列

public static void main(String[] args) {
    //动态初始化格式
    int[] a=new int[3];
    //输出数组中的元素
    System.out.println(a[0]);//赋值前全部默认的为0
    //输出数组名
    System.out.println(a);//[I@50cbc42f 地址
    //数组赋值
    a[0]=100;
    a[1]=200;
    System.out.println(a[0]);
    System.out.println(a[1]);
    System.out.println(a[2]);
    System.out.println("--------------------------------");
    //静态初始化
    //静态初始化不能指定长度
    int[] b=new int[]{12,23,45};
    //静态初始化简化方式
    int[] c={1,2,3};
    System.out.println(c);
    System.out.println(c[0]);
    System.out.println(c[1]);
    System.out.println(c[2]);

    //访问了数组中不存在的索引对应的元素，就会有越界异常：java.lang.ArrayIndexOutOfBoundsException
//        System.out.println(c[3]);

    //访问的数组已经不再指向堆内存的数据，会造成空指针异常：java.lang.NullPointerException
    //把null赋值给数组b
//        b=null;
//        System.out.println(b[0]);
}

运行结果

0
[I@1c53fd30
100
200
0
--------------------------------
[I@50cbc42f
1
2
3

6.两个数组指向同一地址空间问题

6.1代码示列

public static void main(String[] args) {
    int[] a=new int[3];
    a[0]=100;
    a[1]=200;
    a[2]=300;
    System.out.println(a);
    System.out.println(a[0]);
    System.out.println(a[1]);
    System.out.println(a[2]);
    //定义第二个数组指向对一个数组，把都一个数组的地址赋值给第二个数组
    int[] b=a;
    System.out.println(b[0]);
    b[0]=110;
    b[1]=210;
    b[2]=310;
    //两个数组地址相同，只new了一次，只开辟了一块地址空间
    System.out.println(a);
    System.out.println(b);
    //只要一个数组更改了数组元素的值，则两个数组的元素值都会改变
    System.out.println(a[0]);
    System.out.println(b[0]);

}

运行结果

[I@50cbc42f
100
200
300
100
[I@50cbc42f
[I@50cbc42f
110
110

7.数组遍历

数组.length可以获取数组元素数量
7.1代码示列
案例一：遍历数组

public static void main(String[] args) {
    int[] arr={12,23,34,45,56,67,78,89};
    for (int i=0;i<arr.length;i++){
        System.out.print(arr[i]+" ");
    }
}

运行结果

12 23 34 45 56 67 78 89 

案例二：输出班级不及格人数，平均分，总分数

public static void main(String[] args) {
    int[] score={80,90,50,85,90,78,88,89,93,98,75,59};
    int count=0;
    int sum=0;
    int av=0;
    for (int i=0;i<score.length;i++){
        if (score[i]<60){
            count++;
        }
        sum=sum+score[i];
    }
    av=sum/score.length;
    System.out.println("不及格人数："+count);
    System.out.println("总分数："+sum);
    System.out.println("平均分数："+av);
}

运行结果

不及格人数：2
总分数：975
平均分数：81

案例三：求数组的最大值

public static void main(String[] args) {
    int[] arr={12,45,78,64,8};
    int max=arr[0];
    for (int i=0;i<arr.length;i++){
        if (arr[i]>max){
            max=arr[i];
        }
    }
    System.out.println(max);
}

运行结果

78

案例四：冒泡排序

public static void printArr(int[] arr){
    for (int f=0;f<arr.length;f++){
        System.out.print(arr[f]+" ");
    }
    System.out.println();
}
public static void main(String[] args) {
    int[] score={80,90,50,85,90,78,88,89,93,98,75,59};
    System.out.print("原始数组：");
    printArr(score);
    for (int i=0;i<score.length-1;i++){
        for (int j=0;j<score.length-i-1;j++){
            if (score[j]>score[j+1]){
              int temp=score[j];
                score[j]=score[j+1];
                score[j+1]=temp;
            }
        }
        System.out.print("第"+(i+1)+"次排序后的结果：");
        printArr(score);
    }
}

运行结果

原始数组：80 90 50 85 90 78 88 89 93 98 75 59 
第1次排序后的结果：80 50 85 90 78 88 89 90 93 75 59 98 
第2次排序后的结果：50 80 85 78 88 89 90 90 75 59 93 98 
第3次排序后的结果：50 80 78 85 88 89 90 75 59 90 93 98 
第4次排序后的结果：50 78 80 85 88 89 75 59 90 90 93 98 
第5次排序后的结果：50 78 80 85 88 75 59 89 90 90 93 98 
第6次排序后的结果：50 78 80 85 75 59 88 89 90 90 93 98 
第7次排序后的结果：50 78 80 75 59 85 88 89 90 90 93 98 
第8次排序后的结果：50 78 75 59 80 85 88 89 90 90 93 98 
第9次排序后的结果：50 75 59 78 80 85 88 89 90 90 93 98 
第10次排序后的结果：50 59 75 78 80 85 88 89 90 90 93 98 
第11次排序后的结果：50 59 75 78 80 85 88 89 90 90 93 98