java基础Ⅱ

包机制

• 为了更好地组织类
• 语法格式: package ...
• 利用公司域名倒置作为包名
• 导入包: import ...
• 通配符*: import java.lang.*;
• 生成javadoc: tools/generate javadoc

Scanner

• 创建扫描器对象, 接受键盘数据
• Scanner s = new Scanner(System.in);
• s.close(); 及时关闭, 减少资源浪费
• s.next() 和 s.nextline() 获取输入的字符串
• s.hasNext() 和 s.hasNextLine()判断是否还有输入的数据

Switch

switch(expression){
    case value1:
        
        break;
    case value2:
        
        break;
    default:
        
}

• value可以为byte, short, int, char, String (本质上均为数字, 从反编译文件可看出)

增强for循环

for(int i:arrays[10]){
    
}

• 用于遍历数组
• 不能增加, 删除

标签Label

outer: for(int i=101;i<150;i++){
    for(;;){
        if(flag) continue outer;
    }
}

方法

• 语句块, 为了实现某个功能
• 值传递: java中只有值传递, 没有引用传递. 无法改变原值.
• 重载
  • 参数个数不同、类型不同、排列顺序不同
  • 返回类型不同不足以重载
• 可变参数
  • 指定参数类型后，加一个省略号…
  • 必须是最后一个参数
  • public static void max(double... numbers) —— numbers即为可变长度的数组

递归

• 自己调用自己
• 结构
  • 递归头：什么时候跳出递归，获取某个确值
  • 递归体：什么时候仍然调用自身

public static void f(int n){
    if(n==1){
        return 1;
    }
    else{
        return n*f(n-1);
    }
}

• 栈机制：逐层调用，逐层返回。类似于压栈和弹栈

初始化

• 静态初始化

int[] a = {1, 2, 3};
Man[] mans = {new Man(1,1),new Man(2,2)};
int[][] b = {{1,2},{2,3},{3,4}};

• 动态初始化

int[] a = new int[2];

• 默认初始化

Arrays类

• java.util.Arrays
• 一般使用类名进行调用
• 功能
  • 数组赋值：fill()
  • 数组排序：sort()
  • 数组比较：equals()
  • 元素查找：binarySearch()

Arrays(array,0);
Arrays(array,fromIndex:2,toIndex:4,val0)//类似于python切片

冒泡排序

• 总共有八大排序
• 依次两两比较，最大数会冒泡到最后
• 时间复杂度O(n2)
• 优化：都没有交换的话, 即已经排序好

boolean flag;
for (int i = 0; i < n-1; i++) {
    flag = false;
    for (int j = 0; j < n-i-1; j++) {
        //
        //
        //
        flag=true;
    }
    if(!flag){
        break;
    }
}

稀疏数组

• 记录几行、几列、值

//原数组
int[][] array1 = new int[11][12];
array1[3][5] = 12;//4行6列
array1[5][2] = 32;//6行3列
array1[7][8] = 84;//8行9列
int sum=3;
//创建稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;//11行
array2[0][1] = 12;//12列
array2[0][2] = sum;//sum个有效值

int count = 0;
for (int i = 0; i < array1.length; i++) {
    for (int j = 0; j < array1[i].length; j++) {
        if(array1[i][j]!=0){
            count++;
            array2[count][0]=i;
            array2[count][1]=j;
            array2[count][2]=array1[i][j];

        }
    }
}
for (int i = 1; i < array2.length; i++) {
    System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
    System.out.println("");
}

//还原数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];

for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][1]]=array2[i][2];
}

for (int[] ints:array3) {
    for (int anInt:ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println("");
}