随堂笔记5

随堂笔记5

可变参数

1. jdk1.5，java支持传递同类型的可变参数

2. 本质相当于数组

3. 在方法声明中，在指定参数之后加...(省略号)

4. 一个方法中只能有一个可变参数，并且在所有普通参数之后

public class Demo09 {
    public static void main(String[] args) {
        Demo09 demo09=new Demo09();//创建一个对象
        demo09.test(1,2,3,4,5);
    }
    public void test(int ...a){
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
    }
}

java实现计算器

1. 如何键盘输入char类型

   Scanner cin=new Scanner(System.in);
   String s=cin.nextLine();
   char ans=s.charAt(0);

2. switch语句语法说明： 1、 表达式的类型只能为byte、short、char和int这4种之一。 　　　2、 值1、值2…值n只能为常数或常量，不能为变量。 　　　3、 功能代码部分可以写任意多句。 　　　4、 break关键字的意思是中断，指结束switch语句，break语句为可选。 　　　5、 case语句可以有任意多句，是标号语句。 　　　6、 default语句可以写在switch语句中的任意位置，当表达式的值和对应case语句后的值相同时，既从该位置开始向下执行，一直执行到switch语句的结束，在执行中，如果 遇到break语句，则结束switch语句的执行。

3. 如何循环输入？？？

数组

1. 数组的声明 变量的类型+变量的名字=变量的值

public class Demo11 {
    public static void main(String[] args) {
        int[] number;//声明一个数组，数组并不存在，只是在栈中创建了一个指针？？？
        number = new int[10];//创建一个空间为10名字为number的数组，放在堆中
        //或者直接 int[] number1=new int[10];
        int[] a={1,2,3,4,5}//静态声明
    }
}

2. new关键词出来的都存放在堆中

3. 数组小结：

   1. 数组的长度是确定的，一旦被创建，它的大小就不可以改变

   2. 数组不能出现混合类型

   3. 数组的元素可以是任何类型，包括基本类型和引用类型

   4. 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

   5. 数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

4. 增强型for循环

   public class ArrayDemo01 {
       public static void main(String[] args) {
           int[] a={1,2,3,4,5};
           for (int i : a) {//i为数组内的数据
               System.out.println(i);
           }
       }
   }

5. java可以直接传递数组参数（函数之间）

   public class ArrayDemo02 {
       public static void main(String[] args) {
           int[] a={0,1,2,3,4};
           int reverse[]=reverse(a);
           for(int i=0;i<a.length;i++){
               System.out.println(reverse[i]);
           }
   ​
       }
       public static int[] reverse(int[] a){
           int[] b=new int [a.length];
           for(int i=0;i<a.length;i++){
               b[i]=a[a.length-1-i];
           }
           return b;
       }
   }

详细了解一个类

声明一个类，ctrl+鼠标左键进入类，点击屏幕左边下project，进入查看源代码，可在jdk文档帮助中了解源码

import java.util.Arrays;
​
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] a={10,30,100,999,312312,876};
        Arrays.sort(a);//对数组a进行排序:升序
        System.out.println(Arrays.toString(a));//输出整个数组
    }
}

稀疏数组使用储存还原

1. 稀疏数组使用在大多数元素为0时，可以有效地节约空间

//稀疏数组的转化储存和还原
import java.util.Arrays;
​
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[][] array=new int[11][11];//数组的声明，需记忆
        array[1][2]=1;
        array[2][3]=2;
        int sum=0;
        for(int i=0;i<array.length;i++){
            System.out.println(Arrays.toString(array[i]));//输出原数组
        }
        //求出有多少个非零点
        for(int i=0;i<array.length;i++){//循环二位数组的行次
            for(int j=0;j<array[i].length;j++){//循环某行的列次
                if(array[i][j]!=0)
                    sum++;
            }
        }
        System.out.println("========================");
        int[][] array2=new int[sum+1][3];//创建稀疏数组
        int temp=0;
        array2[0][0]=11;//原数组行数
        array2[0][1]=11;//原数组列数
​
        //数据填入稀疏数组
        for(int i=0;i<array.length;i++){//循环二位数组的行次
            for(int j=0;j<array[i].length;j++){//循环某行的列次
                if(array[i][j]!=0){
                    temp++;
                    array2[temp][0]=i;
                    array2[temp][1]=j;
                    array2[temp][2]=array[i][j];
                }
            }
        }
        for(int i=0;i<array2.length;i++){
            System.out.println(Arrays.toString(array2[i]));//输出稀疏数组
        }
        System.out.println("=========================");
​
        //还原稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        for(int i=1;i<array2.length;i++){//注意i的初始值以及循环范围，
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        for(int i=0;i<array3.length-1;i++){//输出还原的稀疏数组
            System.out.println(Arrays.toString(array3[i]));
        }
    }
}