java学习之旅（day.06）

switch多选择结构

多选择结构还有一个实现方式就是switch case

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch(expression){

case value:

//语句

break；

case value;

//语句

break；//可以有任意数量的case语句

default：

//语句

}

switch语句中的变量类型可以是：

byte, short , int或char
javaSE 7开始支持字符串类型了，同时，case标签必须为字符串常量或字面量

package com.zhang.structure;

public class SwitchDemo01 {
    public static void main(String[] args) {
        char grade ='C';
        //switch匹配一个具体的值
        switch (grade){
            case'A':
                System.out.println("优秀");
                break;
            case'B':
                System.out.println("良好");
                break;
            case'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("未知");
        }
    }
}
====================================================
    package com.zhang.structure;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name ="张三";
        //JDK7的新特性，表达式结果可以是字符串
        //字符串的本质还是数字

        //反编译，java文件编译后生成class文件，class文件是字节码文件，人看不懂，
        //需要转为人看懂的文件，即反编译。工具用：IDEA
        //方法：打开Project Structure
        //     找到项目输出路径，可以据此找到class文件在哪，然后将class文件放到
        //对应的java文件中，就可以在IDEA中打开
        switch (name){
            case"张三":
                System.out.println("张三");
                break;
            case"李四":
                System.out.println("李四");
                break;
            default:
                System.out.println("不知道");
        }
    }
}

循环结构

while循环
do...while循环
for循环
在java5中引入了一种主要用于数组的增强型for循环

while循环

while循环是最基本的循环，结构为：

while（布尔表达式）{

//循环内容

}

package com.zhang.structure;

public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1-100
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
====================================================
    package com.zhang.structure;

public class WhileDemo02 {
    public static void main(String[] args) {
        //计算1+2+3+...100的和
        int i=0;
        int sum=0;
        while(i<100){
            i++;
            sum=sum+i;
            //++i;
        }
        System.out.println(sum);
    }
}

只要布尔表达式为true，循环会一直执行下去，但大多数情况会让循环停下来，我们需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等

do while 循环

do while语句表达

do{

//代码语句

}while（布尔表达式）；

对于while循环而言，如不满足条件，则不能进入循环
有时即便不满足条件，我们也至少需要执行一次，此时，就要用到do...while循环，do...while与while循环相似，区别在与do...while至少执行一次
while循环先判断后执行，do...while先执行，后判断。
```
package com.zhang.structure;

public class DoWhile01 {
    public static void main(String[] args) {
     //计算1+2+3+...100
     int i=1;
     int sum=0;
     do{
         sum=sum+i;
         i++;
     }while(i<=100);
        System.out.println(sum);
    }
}
```
For循环

所有的循环后可以用while或do while表示，但java中的For循环会使一些循环结构变得更简单

for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构

for循环的运行次数在执行前就是确定的。

语法格式：

for(初始化；布尔表达式，迭代更新){

//代码语句

}

快速打出for循环：100.for

package com.zhang.structure;

public class ForDemo01 {
    public static void main(String[] args) {
        //初始化//条件判断//迭代更新
        //for(int i=0;i<=100;i++){
            //System.out.println(i);
        //最先执行初始化步骤，可声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
        //然后检查布尔表达式的值，若为true，执行循环，若为false，循环终止，执行循环体后的内容
        //再次检查布尔表达式，执行循环
        //for（；；）死循环
        //==========================================================
        //计算0-100间所有基数和偶数的和
        // (我写的）
        int sum1=0;
        int sum2=0;
        for (int i = 0,s=1; i<100; i+=2,s+=2) {
            sum1=i+sum1;
            sum2=s+sum2;
            System.out.println(i);
            System.out.println(s);
        }
        System.out.println(sum1);
        System.out.println(sum2);
        //老师讲的
        //int oddsum=0;
        //int evensum=0;
        //for (int i = 0; i < 100; i++) {
        //    if(i%2!=0){
        //        oddsum+=i;
        //    }else{
        //        evensum+=i;
        //    }

        //}
        //System.out.println("奇数的和："+oddsum);
        //System.out.println("偶数的和："+evensum);
    }
    }
==================================================
    package com.zhang.structure;

public class ForDemo02 {
    public static void main(String[] args) {
        //用while或for语句输出1-1000间能被5整除的数，且每行输出三个
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }
}
====================================================
    package com.zhang.structure;

public class ForDemo03 {
    public static void main(String[] args) {
        //打印九九乘法表
        //1.打印第一列
        //2.把固定的1再用一个循环包起来，让1也成为变量
        //3.九行九列中有重复的，要去掉重复的
        //4.调整样式
        for (int j = 1; j <=9; j++) {
            for (int i = 1; i <=j; i++) {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

增强for循环

数组的时候使用

增强for循环是一种主要用于数组或集合的

语法格式：

for（声明语句：表达式）

{

//代码句子

}

package com.zhang.structure;

public class ForDemo05 {
    public static void main(String[] args) {
        //增强for循环
       int[] numbers={10,20,30,40,50};//定义了一个数组
for (int x:numbers){//遍历数组的元素：把数组numbers中的每一个元素遍历出来赋值给x
    System.out.println(x);
}
        System.out.println("====================");
//一般的for循环
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
    }
}

break 与continue

break:在任何循环语句的主体部分，均可用break控制循环的流程提前终止循环，break强行退出循环，不执行循环中剩余的语句。继续执行下面的语句

continue：用在循环语句中，提前结束本次循环，即跳过循环中尚未执行的语句，接着执行下一次是否执行循环的判定。循环结束后，继续执行下面的语句

package com.zhang.structure;

public class TestDemo01 {
    public static void main(String[] args) {
//打印三角形5行
        for (int i = 1; i <=5; i++) {
            for (int j = 5; j >=i; j--) {
                System.out.print(" ");
            }
            for (int j = 1;  j<=i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();

                }


    }
}

方法

System.out.println（）

类对象方法

调用系统类里的标准输出对象out中的方法叫做println方法

java方法是语句的集合，他们在一起执行一个功能
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他方法被引用
设计方法的原则：一个方法只完成1个功能，这样有利于后期的扩展

package com.zhang.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
     //int sum=add(1,2);
       // System.out.println(sum);
        test();
    }
    
    //加法
    public static int add(int a,int b){
    //修饰符 返回值类型
        return a+b;
    }
    public static void test(){
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }

}

方法的定义

java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法

修饰符返回值类型方法名（参数类型参数名）{

方法体

return 返回值；

}
方法包含一个方法头和方法体，下面是一个方法的所有部分：

修饰符：是可选的（可以不写），告诉编译器如何调用该方法，定义该方法的访问类型

返回值类型：方法可能返回值，有些方法执行所需的操作，但没有返回值，在这种情况下，returnValueType（返回值类型）是关键字void

方法名：方法的实际名称，随便取，但要遵守规范：首字母小写驼峰原则

参数类型：实参和形参

实参：参数像个占位符，当方法被调用时，传递值给参数，这个值称为实参或变量（在方法被调用时用于接收外界输入的数据）

形参：调用方法时实际传递给方法的数据

参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数

package com.zhang.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        //实际参数：实际调用传递给他的参数
       int sum=add(1,2);
       System.out.println(sum);
        //test();
    }

    //加法
    //形式参数：用来定义作用的
    public static int add(int a,int b){
    //修饰符 返回值类型
        return a+b;
    }
    public static void test(){
        for (int i = 0; i <=100; i++) {
            if (i%5==0){
                System.out.print(i+"\t");//空格
            }
            if (i%(3*5)==0){//每行3个
                System.out.println();//换行，也可用System.out.print(“\n”);
            }
//print与println的区别：print输出不会换行，println输出后会换行
        }
    }

}

方法体：方法包含具体的语句，定义该方法的功能

返回值：如果方法存在返回值，一定要把返回值通过return这个关键词返回出去，如果是void就不用返回了

方法调用

调用方法：对象名.方法名（实参列表）
java支持两种调用方法的方式，根据方法是否返回值来选择
1. 当方法返回一个值得时候，方法调用通常被当做一个值。如：int larger =max（30，40）；
2. 如果方法返回值是void，方法调用一定是一条语句

如：System.out.println("hello,zhang“）；

package com.zhang.method;

public class Demo02 {
    public static void main(String[] args) {
int max=max(10,20);
        System.out.println(max);
    }
    //比大小
    public static int max(int num1,int num2){//形式参数
        int result=0;//这里result的初始化值写多少都行，后面会被覆盖
        if (num1==num2) {
            System.out.println("num1=num2");
            return 0;//return除了返回结果的意思，还有终止方法的作用
        }
        if(num1>num2){
            //这里写return会报错，一般return写到最外边，为了将num1返回出去，要定义一个变量result
            result=num1;
        }else{
            result=num2;
        }
return result;
    }
}

值传递（java）和引用传递

值传递和引用传递

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载原则：

方法名称必须相同
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个去匹配，以选择对应的方法，如果匹配失败，则编译器报错

命令行传参（了解）

有时候希望运行一个程序的时候再传递给它消息，这要靠传递命令行参数给main（）函数实现

可变参数

1.5开始，java开始支持传递同类型的可变参数给一个方法

在方法声明中，在指定参数的类型后加一个省略号(...).

一个方法只能指定一个可变参数，且必须是方法的最后一个参数。任何普通参数必须在它之前声明

package com.zhang.method;

public class Demo05 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(34,3,3,2,56.5);//给一组数
        printMax(new double[]{1,2,3});//传给一个数组

    }
    public static voizd printMax(double...numbers){//传递多个double类型的参数
        if (numbers.length==0){
            System.out.println("no argument passed");
            return;
        }
        double result =numbers[0];

        //排序
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i]>result){
                result=numbers[i];
            }

        }
        System.out.println("Max value is:"+result);
    }
}

递归

递归就是A方法调用A方法，即自己调用自己

利用递归可以用简单地程序来解决一些复杂的问题，通常把复杂的大型问题层层转化为一个与原问题相似的规模较小的问题求解

递归结构包括两个部分：

递归头：什么时候不调用自身的方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身的方法

基数比较大的时候能不用递归就不用递归

package com.zhang.method;

public class Demo07 {
    public static void main(String[] args) {
        System.out.println(f(5));//此处基数过大的话，能不用递归就不用递归
    }
    public static int f(int n){
        if (n==1){
            return 1;
        }else{
           return n*f(n-1);
        }

    }
}

数组

相同类型的数的有序集合

数组声明创建

首先必须声明数组变量，才能在程序中使用数组，声明数组变量的语法如下：

dataType[]arrayRefvar；//首选的方法

或

dataType arrayRefvar[]；//效果相同，但不是首选的方法

java使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar=new dataType[arraySize];

数组的元素通过索引来访问，数组索引从0开始

获取数组的长度 arrays.length

package com.zhang.array;

public class ArrayDEMO01 {
    public static void main(String[] args) {
        //变量类型 变量名=变量值；
        //定义一个数组有以下两种方法：
        int[] nums;//首选
        //int类型的数组
        int nums2[];//在c或c++中使用的多，上面两种方法仅仅声明了一个数组，并没有分配空间，下面一行分配了空间
        nums=new int[10];//这里面可以存放10个int类型的数字,创建了一个数组
        //也可以将上面两句话合成一句话：声明并创建：int[] nums =new int[10]
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;//给数组元素赋值
        System.out.println(nums[0]);
        int sum=0;
        //计算所有元素的和
        for (int i = 0; i < nums.length; i++) {
           sum=sum+nums[i];
        }
        System.out.println("总和为："+sum);


    }
}

数组的三种初始化

静态初始化

int[] a={1,2,3};

Man[] mans={new Man(1,1),new Man(2,2)};

动态初始化

int[] a=new int[2];

a[0]=1;

a[1]=2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化

package com.zhang.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
      //静态初始化:创建加赋值
        int[] a={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
        //动态初始化,包含默认初始化
        int[] b=new int[10];
        b[0]=1;
    }
}

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任意数据类型，包括基本类型和引用类型
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中的对象是在堆中，因此，数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组的边界

下标的合法区间：[0,length-1],如果越界就会报错

比如：数组的长度是10，则下标的有效区间是0-9

数组下标越界异常：ArrayIndexOutOfBoundsException

数组的使用

For-Each循环
数组做方法用参
数组做返回值
普通for循环

package com.zhang.array;

public class ArrayDemo03 {
    public static void main(String[] args) {
      int[] arrays={1,2,3,4,5};
       // for (int array : arrays) {//增强型for循环
            //数组里面的每一个元素    数组
        //    System.out.println(array);
       // }
        //printArray(arrays);
        int[] reverse=reverse (arrays);
        System.out.println(reverse);
        printArray(reverse);
    }
    //打印数组元素(数组做方法用参）
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    //反转数组，（数组作为返回值的情况）
    public static int[] reverse(int[] arrays){
     int[] result=new int[arrays.length];
    //反转的操作
        for (int i = 0,j=result.length-1; i <arrays.length; i++,j--) {
            result[j]=arrays[i];
        }
     return result;
    }
}

多维数组

多维数组可看成数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

二维数组：

int a[] []=new int[2] [5];//2行5列的数组

原来一维中存个数，现在二维存的是数组

多维：数组里面嵌数组

package com.zhang.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        //4行2列
        /*
        1,2    array[0]
        2,3    array[1]
        3,4    array[2]
        4,5    array[3]
         */
        int[][] array={{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array[0][0]);//1
        System.out.println(array[2][1]);//4
        printArray(array[0]);//1 2
        System.out.println("============");
        //输出数组的长度
        System.out.println(array.length);//4
        System.out.println(array[0].length);//2
        System.out.println(array[1].length);//2
        //输出二维数组中的元素
        System.out.println("=======");
        for (int i = 0; i < array.length; i++) {
            for (int j=0; j<array[i].length; j++) {
                System.out.println(array[i][j]);
            }


        }
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length; i++) {
            System.out.print(arrays[i]+" ");

        }
    }
}

Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而科一对数据对象进行一些基本的操作

可以查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而不用使用对象来调用，你想用也行

常用功能：

给数组赋值：通过fill方法
对数组进行排序：通过sort方法（升序）
比较数组：通过equals方法比较数组中元素值是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作

package com.zhang.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,9900,5486,5,98,3};
        System.out.println(a);//[I@14ae5a5
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printArray(a);
        //对数组中的元素进行排序
        Arrays.sort(a); //升序排序
        System.out.println(Arrays.toString(a));
        //给数组赋值，（填充）
        Arrays.fill(a,0);//把数组a的元素填充为0
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4 ,0);//把数组a的下标为2-4的元素填充为0
        System.out.println(Arrays.toString(a));
    }
    //自己写一个方法打印出数组
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==8){//或写成i==a.length-1
                System.out.println(a[i]+"]");
            }else {
                System.out.print(a[i] + ", ");
            }
        }
    }
}

冒泡排序

package com.zhang.array;

import java.util.Arrays;

public class ArrayDemo07 {
    //冒泡排序:时间复杂度为O（n^2）
    //1.比较数组中两个相邻的元素，如果第一个>第二个，则交换位置
    //2.每次比较都会产生一个最大或最小的数字
    //3.下一轮就可以少一次排序
    //一次循环，直至结束
    public static void main(String[] args) {
        int[] a={1,8,6,7,9,89,56,45,198,237};
        int[] sort = sort(a);//调用完自己写的排序方法后返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }
public static int[] sort(int[] array){
        int temp=0;
        //外层循环，判断要走多少次
        for (int i = 0; i <array.length-1; i++) {
            boolean flag=false;//优化，通过flag标识符减少没有意义的比较
        //内层循环，比较；两个数，如果第一个数比第二个数大，则交换位置
        for (int j = 0; j < array.length-1-i; j++) {//优化：假设进来这些循环时已经有序了就不需要再比较了
            if (array[j+1]>array[j]){
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
                flag=true;//优化，排完续的flag置为true，若都没有交换，flag=false
            }
        }
            if (flag==false) {//优化，说明这一轮没有进行比较，说明结束了
                break;
    }

    }
    return array;
}
}

稀疏数组

压缩，数据量变小

当一个数组中大部分为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组
稀疏数组的处理方式：

记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而减小规模
如下：左为原始数组。右为稀疏数组

1.7

6 7 8 6行7列8个有效的数字

0 3 22 第0行第3列的值是22

package com.zhang.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
    //1.创建一个二维数组11*11  0：没有棋子 1：黑棋  2：白棋

        int[][] array1=new int[11][11]; //一个11*11的二维数组，但此时没有赋值，都是0
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组：");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组来保存
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0;  j< 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组对应的数组
        int[][] array2=new int[sum+1][3];  //多少行多少列
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        //遍历二维数组，将非0的值存放在稀疏数组中
        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];
                }
            }
            
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i <array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+ array2[i][1]+"\t"+ array2[i][2]+"\t");
        /*
        11  11  2
        1   2   2
        2   3   3
         */
        }
        //还原稀疏数组
        System.out.println("还原稀疏数组：" );
        //1.读取稀疏数组的值
        int[][] array3=new int[array2[0][0]][array2[0][1]];  //数组大小
        //2.给其中的元素还原值
        for (int i = 1; i <array2.length; i++) {//这里i从1开始，不是o，第一行是头部信息
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //3.打印输出
        System.out.println("输出还原后的数组：");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

posted on 2021-01-06 23:32 懵逼的程序小白阅读(50) 评论(0) 收藏举报