java _循环练习和数组练习

练习

1.输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，如153 = 1*1*1 + 3*3*3 + 5*5*5(很经典的题目)

分析:

通过观察发现，本题目要实现打印符合要求的数字（即水仙花数）。

1. 明确什么样的数就是水仙花数。水仙花数是指一个3位数（100-999之间），其每位数字立方之和等于该3位数本身。如153 = 1*1*1 + 3*3*3 + 5*5*5，

即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方;

1. 获取水仙花范围内的所有3位数（100-999之间的每个3位数）
2. 判断该3位数是否满足水仙花数，满足，打印该3位数

解题步骤：

1. 使用for循环，得到100-999之间的每个3位数
2. 获取3位数中百位数字、十位数字、个位数字
3. 使用if条件语句，判断该3位数是否满足水仙花数，满足，使用输出语句，打印该3位数

ublic class Test02 {
    public static void main(String[] args) {
        for (int i = 100; i < 1000; i++) {
            int bai = i/100%10;
            int shi = i/10%10;
            int ge = i%10;
            
            if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
                System.out.println(i);
            }
        }
    }
}

在介绍这个题前,我们先学习ASCII码表吧

 American Standard Code for Information Interchange，美国标准信息交换代码.

在计算机中，所有的数据在存储和运算时都要使用二进制数表示, a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。

数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，字母A-Z对应ASCII编码十进制为65-90,记住!!!

2.利用for循环打印ABCDEFG...XYZ，26个大写字母与26个小写字母:

public class Test04 {
    public static void main(String[] args) {
        char da = 'A';
        char xiao = 'a';
        for (int i = 0; i < 26; i++) {
            System.out.println("大写字母 "+da+" ,小写字母 "+xiao);
            da++; //更新大写字母值
            xiao++; //更新小写字母值
        }
    }
}

3. 利用for循环打印 9*9 表?

    for (int j = 1; j < 10; j++) {
            for (int k = 1; k <= j; k++) {
                System.out.print(k +"*"+ j +"="+ j*k +"	");
            }
            System.out.println();
        }
    }
}

4.编写程序求 1+3+5+7+……+99 的和值

public class Test01 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i%2==1) {
                sum += i;
            }
        }
        System.out.println("累加和的值 " + sum);
    }
}

 我们可以先预习一下数组(点)

一维数组:

1.根据键盘录入索引,查找对应星期几:

2.数组元素查找(查找指定元素第一次在数组中出现的索引)

3.数组获取最值(获取数组中的最大值最小值)

class Demo3_Array {
    public static void main(String[] args) {
        int[] arr = {33,77,22,44,55};
        int max = getMax(arr);
        System.out.println(max);
    }

    /*
    获取数组中最大值
    1,返回值类型int
    2,参数列表int[] arr
    */

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1;i < arr.length ;i++ ) {            //从数组的第二个元素开始遍历
            if (max < arr[i]) {                            //如果max记录的值小于的数组中的元素
                max = arr[i];                            //max记录住较大的
            }
        }

        return max;
    }
}

4.定义打印数组元素方法,按照给定的格式打印[11, 33, 44, 22, 55]

public static void printArray(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length; i++) {
        if (i == arr.length - 1) {
            System.out.println(arr[i]+"]");
        } else {
            System.out.print(arr[i]+", ");
        }
    }
}

5.实现原数组元素倒序存放操作

//数组元素逆序
public static void receive(int[] arr){
    for (int start = 0, end = arr.length-1; start < end; start++,end--) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

6.数组元素的选择排序:

题目分析：

         通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序

1. 提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2. 上图中用每圈要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中。
3. 数组再循环一圈后，把第二小的元素值互换到了第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为选择排序。

解题步骤：

1. 使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
2. 在每一圈中，通过for循环（内层循环）完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中
3. 在每一圈中，要参与比较的第一个元素由第几圈循环来决定。如上图所示

              a)       进行第一圈元素比较时，要比较的第一个元素为数组第一个元素，即索引为0的元素

              b)       进行第二圈元素比较时，要比较的第一个元素为数组第二个元素，即索引为1的元素

              c)        依次类推，得出结论：进行第n圈元素比较时，要比较的第一个元素为数组第n个元素，即数组索引为n-1的元素

public static void selectSort(int[] arr) {
    //功能
    //外层循环用来控制数组循环的圈数
    for (int i = 0; i < arr.length-1; i++) {
        //内层循环用来完成元素值比较，把小的元素值互换到要比较的第一个元素中
        for (int j = i+1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

7.数组冒泡排序:

图解：数组元素{13,46,22,65,3}

题目分析：

         通过观察发现，本题目要实现把数组元素{13,46,22,65,3}进行排序

1. 提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2. 上图中相邻的元素值依次比较，把大的值放后面的元素中，数组循环一圈后，则把最大元素值互换到了最后一个元素中。数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为冒泡排序。

解题步骤：

1. 使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
2. 在每一圈中，通过for循环（内层循环）完成相邻的元素值依次比较，把大的值放后面的元素中
3. 每圈内层循环的次数，由第几圈循环来决定。如上图所示

                 a)       进行第一圈元素比较时，内层循环次数为数组长度 - 1

                 b)       进行第二圈元素比较时，内层循环次数为数组长度 - 2

                 c)        依次类推，得出结论：进行第n圈元素比较时，内层循环次数为数组长度 - n

//冒泡排序
public static void bubbleSort(int[] arr) {
    //功能
    //外层循环用来控制数组循环的圈数
    for (int i = 0; i < arr.length-1; i++) {
        //j < arr.length-1 为了避免角标越界
        //j < arr.length-1-i 为了比较效率,避免重复比较
        //内层循环用来完成元素值比较，把大的元素值互换到后面
        for (int j = 0; j < arr.length-1-i; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

8.数组元素二分查找:

图解:

//二分查找法(折半查找法)
public static int halfSearch(int[] arr, int number) {
    //定义3个变量，用来记录min, min, mid的位置
    int min = 0;
    int max = arr.length-1;
    int mid = 0;
        while (min <= max) {
           mid = (min+max)/2;
        //没找了， 更新范围，继续比较
        //更新范围
        if (arr[mid] > number) {
            //在左边
            max = mid-1;
        } else if(arr[i] < number){
            //在右边
            min = mid+1;
        }
        else{
              return mid ;
          }
     
    return -1;
}

二维数组:

 1.二维数组遍历

class Test1_Array {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

        for (int i = 0;i < arr.length ;i++ ) {            //获取到每个二维数组中的一维数组
            for (int j = 0;j < arr[i].length ;j++ ) {    //获取每个一维数组中的元素
                System.out.print(arr[i][j] + " ");
            }

            System.out.println();
        }
    }
}

2.需求：公司年销售额求和, 某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22,66,44
        第二季度：77,33,88
        第三季度：25,45,65
        第四季度：11,66,99

class Test2_Array {
    public static void main(String[] args) {
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        int sum = 0;                                    //定义变量,记录每次相加的结果
        for (int i = 0;i < arr.length ;i++ ) {            //获取每一个一维数组
            for (int j = 0;j < arr[i].length ;j++ ) {    //获取每一个一维数组中的元素
                sum = sum + arr[i][j];                    //累加
            }
        }

        System.out.println(sum);
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------

补充
基本数据类型的值传递,不改变原值,因为调用后就会弹栈,局部变量随之消失
引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问
我们可以通过下面代码了解:

class Test3_Array {
    public static void main(String[] args) {
        /*int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b);            //a = 10,b = 20
        change(a,b);
        System.out.println("a:"+a+",b:"+b);            //?*/

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]);
    }

    public static void change(int a,int b) {        //a = 10, b= 20
        System.out.println("a:"+a+",b:"+b);            //a = 10,b = 20
        a = b;                                        //a = 20
        b = a + b;                                    //b = 40
        System.out.println("a:"+a+",b:"+b);            //a = 20, b = 40
    }

    public static void change(int[] arr) {            //1,4,3,8,5
        for(int x=0; x<arr.length; x++) {
            if(arr[x]%2==0) {
                arr[x]*=2;
            }
        }
    }
}

可以如下图解

基本数据类型的值传递:

 引用数据类型的值传递

Java中到底是传值还是传址?
1,既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
2,java中只有传值,因为地址值也是值(出去面试都说这种,支持者是高司令(java之父))