Day004 20210209-20210217

最新推荐文章于 2021-04-26 16:17:26 发布

黑白黄条纹猫

最新推荐文章于 2021-04-26 16:17:26 发布

阅读量316

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/blacknewcat/article/details/113850453

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Day 004 20210209-20210217

中间10天，涉及节日、小聚会、走亲访友等活动，因此看得较为分散，直到把“零基础”中的“零”看完了，“基础”还没看，正好总结一下。

Scanner类

// 导入java工具包中的Scanner类：
import java.util.Scanner;

public class Demo01{
    public static void main(String[] args){ 
        // 创建一个scanner：
        Scanner scanner = new Scanner(System.in);
        
        // 使用next方法接收：
        // （从第一个有效字符至第一个无效字符（“ ”）前的内容，如"   asd qwr"输入"asd"。）
        // 判断是否输入，并提取输入值：
        if(scanner.hasNext()){
            String str = scanner.next();
            System.out,println("输出的内容为："+str);
        }
        
        // 使用nextLine方法接收：
        // （全部，包括第一个有效字符前的无效字符（“ ”），如"   asd qwr"输出"   asd qwr"。）
        if(scanner.hasNextLine()){
            String str2 = scanner.nextLine();
            System.out.println("输出的内容为："+str2);
        }
        
        /*
        其它scanner方法：
        scanner.nextInt;
        scanner.nextLong;
        scanner.nextByte;
        。。。
        */
        
        // 关闭scanner：
        scanner.close;
    }
}

顺序结构

JAVA最基本的结构是顺序结构。

选择结构

if选择结构

if单选择结构

/*
if(布尔值){
	如果布尔值为true则执行
}

if(!布尔值){
	如果布尔值为false则执行
}
*/

int a = 0;
int b = 0;
if(a > b){
    System.out.println("max= "+a)
}

if(a == 0){
    System.out.println("a数值未改变！")
}

if双选择结构

int a = 0;
int b = 0;
if(a > b){
    System.out.println("a比b大！")
}else {
    System.out.println("a不比b大！")
}

//可用三元运算符 ? : 达到相同的目的。

if多选择结构

int a = 0;
int b = 0;
if(a > b){
    System.out.println("a比b大！")
}else if(a == b){
    System.out.println("a和b一样大!")
}else {
    System.out.println("a比b小！")
}

嵌套if结构

switch选择结构

switch可以用byte、short、int、char或者String作为变量类型。

switch(expression){
    case value1: // 冒号“:”
        // 语句1
        break; // 不写break会造成case穿透，即执行该语句及之后的所有语句，但有时会故意利用这一点。
        
    case value2: // 冒号“:”
        // 语句2
        break;
        
    case value3: // 冒号“:”
        // 语句3
        break;
        
    default: // 冒号“:”
        // 语句4
}

循环结构

While循环结构

若不符合初始条件，则不进行循环。

int i = 101;
int sum = 0;

while(i <= 100){
    sum += i;
    i++;
}

System.out.println("sum = "+sum); // 0

DoWhile循环结构

若不符合初始条件，也进行一次循环。

int i = 101;
int sum = 0;

do{
    sum += i;
    i++;
}while(i <= 100);

System.out.println("sum = "+sum); // 101 分号“;”注意不遗漏。

For循环结构

int sum = 0;

for(int i = 1; i <= 100; i++){ // 分号“;”连接。
    sum += i;
}

System.out.println("sum = "+sum); // 5050

增强for循环结构

for(声明语句 : 表达式){
    // 语句
}

int[] nums = {1,2,3,4,5,6,7,8,9,0};

// 遍历nums中的所有元素：
for(int x:nums){
    System.out.print(x+"\t"); // print为不换行，"\t"为制表符tab。
} // 1	2	3	4	5	6	7	8	9	0

break, continue, goto

break: 强行退出单个循环。（如果嵌套多个则需要连续break来退出整个循环。）（switch之中也用到。）

continue: 跳过该次循环并继续。

goto: 不常用。标识符label，break或者continue到标识符所在。

outer: for(int i = 1; i <= 100; i++){
    for(int j = i; j <= 200; j++){
        if(j == 2 * i){
            continue outer;
        }
        System.out.print(j+"\t");
    }
    System.out.println(); // 相当于换行。
}

方法

方法的定义

有返回值

public static int cattt(int a, int b){ // 返回值为整数。
    int c = a + b;
    return c;
}

public static int[] cattt2(int[] a2, int[] b2){ // 返回值为整数数组。
    int[] c2 = new int[2];
    int suma2 = 0;
    int sumb2 = 0;
    
    for(i = 0; i < a2.length; i++){ // a2.length为a2中的元素个数。
        suma2 += a2[i];
    }
    
    for(j = 0; j < b2.length; j++){
        sumb2 += b2[i];
    }
    
    c2[1] = suma2 + sumb2;
    c2[2] = suma2 - sumb2;
    
    return c2;
}

无返回值

public static void doggg(int a, int b){
    System.out.println("Dog!");
    return; // 可写可不写。
}

方法的调用

方法有static（静态方法）

import java.util.Scanner;

public class Demo02{
    public static void main(String[] args){
        int d = 0;
        int f = 0;
        Scanner scanner = new Scanner(System.in);
        
        if(scanner.hasNextInt()){
            d = scanner.nextInt; // 1
        }
        
       
       
        int g = cattt(d, f); // 1 调用有返回值的方法。
        int g2 = Demo05.tests2(d, f); // 非同一类内。
        System.out.println(g); // 1 调用无返回值的方法。
    }
    
    public static int cattt(int a, int b){ // 返回值为整数。
    int c = a + b;
    return c;
	}
}

方法无static（非静态方法）

public class Demo03{
    public static void main(String[] args){
        Demo03 demo03 = new Demo03();
        demo03.tests(3); // 3
        
        Demo05 demo05 = new Demo05();
        demo05.tests2(3);
    }
    
    public void tests(int a){ // 方法无static。
        System.out.println(a);
    }
}

方法的重载

方法名称相同；
参数列表不同；
返回类型可以相同也可以不同。

public class Demo04{
    public static void main(String[] args){
        System.out.println(cattt(1,2)); // 3
        System.out.println(cattt(1.0,2)); // 3.0
        System.out.println(cattt(1,2.0)); // -1.0
    }
    
    public static int cattt(int a, int b){ // 返回值为整数。
    int c = a + b;
    return c;
	}
    
    public static double cattt(double a, int b){ // 返回值为整数。
    double c = a + b;
    return c;
	}
    
    public static double cattt(int a, double b){ // 返回值为整数。
    double c = a - b;
    return c;
	}
}

命令行传参

注意，包名写于类名处，而不是路径处。
如下所示：

注释图01

可变参数

在指定参数类型后加一个省略号；
一个方法只能申明一个可变参数，且必须是方法的最后一个参数。

public class Demo05{
    public static void main(String[] args){
        Demo05 demo05 = new Demo05();
        demo05.tests2(1,2.0,3,4,5,6,7,8); // 345678
    }
    
    public void tests2(int j, double k, int... i){ // 可变参数。
        System.out.print(i[0]);
        System.out.print(i[1]);
        System.out.print(i[2]);
        System.out.print(i[3]);
        System.out.print(i[4]);
        System.out.print(i[5]);
    }
}

递归

调用自身。

递归头必须要有，以免陷入死循环。

public class Demo06{
    public static void main(String[] args){
        System.out.println(cal(3)); // 6
    }
    
    public static int cal(int i){
        if(i == 1){
            return 1; // 递归头
        }else {
            return (i * cal(i - 1)); // 递归体
        }
    }
}

数组

数组的申明创建及三种初始化

int[] a = new int[5]; // 默认初始化，a = {0,0,0,0,0};。

int[] b;
b = new int[5];

int[] c ={1,2,3,5,4}; // 静态初始化，无法更改。

int[] d = new int[5]; // 动态初始化，无法更改数组长度。
d[0] = 1;
d[1] = 2;
d[2] = 3;
d[3] = 5;
d[4] = 4;

下标越界

ArrayIndexOutOfBoundsException（数组下标越界异常）。

Foreach循环

遍历整个数组，较为方便，但无法获取数组下标。

public class Demo07{
    public static void main(String[] args){
        int nums = {1,2,3,4,5};
        
        for(int num : nums){ // Foreach循环
            System.out.print(num); // 12345
        }
    }
}

多维数组

int[][] nums = new int[5][5];

int[] a = {1,2,3,4,5};
int[] b = {1,2,3,4,5};
int[][] c = {{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5}};

int[][] d = new int[5][5];
for(int i = 0; i < d.length; i++){ // d.length为d的行数。
    for(int j = 0; j < d[0].length; j++){ // d[0].length为d[0]的元素个数，即d的列数。
        d[i][j] = a[i] * b[j];
    }
}

int sum = 0;
for(int[] int : d){ // Foreach循环
    for(anInt : int){ // Foreach循环
        System.out.print(anInt+"\t");
        sum += anInt;
    }
    System.out.println();
}
System.out.println("sum = "+sum); // 225

Arrays类

给数组赋值：fill；
对数组排序：sort；
比较数组：equal；
查找数组元素：对排序好的数组通过boundarySearch进行二分查找法操作。

Arrays.sort(test03); // 排序数组

System.out.println(Arrays.toString(test03)); // 输出数组

冒泡排序

public static int[] bubble(int[] nums){
    int b;

    for (int i = 0; i < nums.length; i++) {
        for (int j = nums.length - 2; j >= i; j--) {
            if(nums[j] > nums[j + 1]){
                b = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = b;
            }
        }
    }
    return nums;
}

稀疏数组

注释图02

public class Demo07 {
    public static void main(String[] args) {
        // 创建二维数组：
        int[][] cattt = new int[5][5];
        cattt[1][2] = 1;
        cattt[2][3] = 2;
        cattt[2][4] = 2;

        // 打印二维数组：
        for (int[] ints : cattt) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        // 创建稀疏数组：
        int count = 0;

        for (int[] value : cattt) {
            for (int j = 0; j < cattt[0].length; j++) {
                if (value[j] != 0) {
                    count++;
                }
            }
        }

        int[][] doggg = new  int[count + 1][3];

        doggg[0][0] = cattt.length;
        doggg[0][1] = cattt[0].length;
        doggg[0][2] = count;
        count = 0;

        for (int i = 0; i < cattt.length; i++) {
            for (int j = 0; j < cattt[0].length; j++) {
                if(cattt[i][j] != 0){
                    count++;

                    doggg[count][0] = i;
                    doggg[count][1] = j;
                    doggg[count][2] = cattt[i][j];
                }
            }
        }

        // 打印稀疏数组：
        for (int i = 0; i < count + 1; i++) {
            System.out.println(doggg[i][0]+"\t"+doggg[i][1]+"\t"+doggg[i][2]);
        }

        // 还原：
        int[][] meoww = new int[doggg[0][0]][doggg[0][1]];
        for (int i = 1; i < doggg.length; i++) {
            meoww[doggg[i][0]][doggg[i][1]] = doggg[i][2];
        }

        // 打印还原数组：
        for (int[] ints : meoww) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

Tips

各种for循环的缩写：
1. fori（for(int i; i < (); i++){…}）；
2. 10.for（for(int i; i < 10; i++){…}）；
3. a.for（for(ints : a){…}）；
4. ints.for（for(anInt : ints){…}）；
2021年02月16日下午【鲜】值得记录，写入阶段性Tips中。

黑白黄条纹猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day004 20210209-20210217

Day 004 20210209-20210217中间10天，涉及春节、小聚会、走亲访友等活动，因此看得较为分散，直到把“零基础”中的“零”看完了，“基础”还没看，正好总结一下。Scanner类// 导入java工具包中的Scanner类：import java.util.Scanner;public class Demo01{ public static void main(String[] args){ // 创建一个scanner： Scanner
复制链接

扫一扫