JavaSEDemo03基础语法

╰+哭是因爲堅強的太久メ 2021-09-25 05:52 203阅读 0赞

### 文章目录 ###

*  简介
 *  while和do-while的区别
 *  switch-case能使用的数据类型
 *  continue关键字与标号
 *   *  continue不带标号
     *  continue带标号
 *  break关键字与标号
 *   *  break不带标号
     *  break带标号
 *  普通for循环和增强for循环遍历一维数组
 *   *  普通for循环
     *  增强for循环
 *  普通for循环和增强for循环遍历二维数组
 *   *  普通for循环
     *  增强for循环
 *  选择排序
 *  冒泡排序
 *  插入排序
 *  练习
 *   *  练习1
     *  练习2
     *   *  while
         *  do-while
     *  练习3
     *  练习4
     *  练习5
     *  练习6
     *  练习7
     *  练习8
     *  练习9
     *  练习10

# 简介 #

*  本文是2021/03/22深夜和2021/03/23凌晨整理的笔记
 *  本文中的选择排序 冒泡排序 插入排序都是通过从小到大排序进行说明的
 *  赘述可能有点多，还请各位朋友耐心阅读
 *  本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进。

# while和do-while的区别 #

*  while语法:while(条件判断)\{循环体\}
 *  do-while语法:do\{循环体\}while(条件判断);
 *  二者的区别:while先进行条件判断，如果条件不满足，循环体一次也不执行;do-while先执行循环体，然后进行条件判断，如果条件不满足，只执行这一次。

# switch-case能使用的数据类型 #

*  JDK1.5前，可以使用基本数据类型byte short int  
      
    不能使用char float double long booean
 *  JDK5以后，新增枚举(enum)
 *  JDK7以后，新增字符串String

# continue关键字与标号 #

## continue不带标号 ##

public class Test { 
        public static void main(String[] args) { 
            for (int i = 0; i < 3; i++) { 
                for (int j = 0; j < 3; j++) { 
                    if(i==j){ 
                        continue;
                    }
                    System.out.println("i:"+i+" j:"+j);
                }
            }
        }
    }

程序运行结果

i:0 j:1
    i:0 j:2
    i:1 j:0
    i:1 j:2
    i:2 j:0
    i:2 j:1

## continue带标号 ##

*  说明  
    continue带标号的话，会直接开始指定的某个循环的下一次循环

public class Test { 
        public static void main(String[] args) { 
           loop1: for (int i = 0; i < 3; i++) { 
           loop2:     for (int j = 0; j < 3; j++) { 
                    if(i==j){ 
                        continue loop1;
                    }
                    System.out.println("i:"+i+" j:"+j);
                }
    
            }
        }
    }

程序运行结果

i:1 j:0
    i:2 j:0
    i:2 j:1

# break关键字与标号 #

## break不带标号 ##

public class Test { 
        public static void main(String[] args) { 
            for (int i = 0; i < 3; i++) { 
            for (int j = 1; j < 3; j++) { 
                    if(i==j){ 
                        break ;
                    }
                    System.out.println("i:"+i+" j:"+j);
                }
    
            }
        }
    }

程序运行结果

i:0 j:1
    i:0 j:2
    i:2 j:1

## break带标号 ##

*  说明:  
    break带标号的话， 会直接跳出指定的某个循环

public class Test { 
        public static void main(String[] args) { 
            loop1:for (int i = 0; i < 3; i++) { 
            loop2:for (int j = 1; j < 3; j++) { 
                    if(i==j){ 
                        break loop1;
                    }
                    System.out.println("i:"+i+" j:"+j);
                }
    
            }
        }
    }

程序运行结果

i:0 j:1
    i:0 j:2

# 普通for循环和增强for循环遍历一维数组 #

## 普通for循环 ##

public class Test { 
        public static void main(String[] args) { 
          int[] array = { 5,4,3,2,1};
            for (int i = 0; i < array.length; i++) { 
                System.out.println(array[i]);
            }
        }
    }

程序运行结果

5
    4
    3
    2
    1

## 增强for循环 ##

*  说明:  
    自JDK1.5以后，出现了增强for循环，专门用来遍历数组和集合。其内部原理是一个Iteration迭代器，在遍历的过程中，不能对数组和集合中的元素进行增删操作。

public class Test { 
        public static void main(String[] args) { 
          int[] array = { 5,4,3,2,1};
             for(int x:array){ 
                 System.out.println(x);
             }
        }
    }

程序运行结果

5
    4
    3
    2
    1

# 普通for循环和增强for循环遍历二维数组 #

## 普通for循环 ##

public class Test { 
        public static void main(String[] args) { 
          int[][] array = { { 1,2,3},{ 4,5,6},{ 7,8,9}};
            for (int i = 0; i < array.length; i++) { 
                for (int j = 0; j < array[i].length; j++) { 
                    System.out.print(array[i][j]+" ");
                }
                System.out.println();
            }
    
        }
    }

程序运行结果

1 2 3 
    4 5 6 
    7 8 9

## 增强for循环 ##

public class Test { 
        public static void main(String[] args) { 
          int[][] array = { { 1,2,3},{ 4,5,6},{ 7,8,9}};
          //一维数组row来接收数组array每行的所有数据
         for(int [] row:array){ 
             //column来接收每行中的每个数据
            for(int column:row){ 
                System.out.print(column+" ");
            }
             System.out.println();
         }
        }
    }

程序运行结果

1 2 3 
    4 5 6 
    7 8 9

# 选择排序 #

*  基本思想:  
    寻找未排序中最小的元素加入到已有序列,直到未排序序列为空。
 *  个人解释:最多进行数组的长度减1趟排序，每一趟排序中找到最小的值，并赋值交给最左侧，每趟排序最左侧的数会加1

import java.util.Arrays;
    
    public class Test { 
        public static void main(String[] args) { 
                int [] array = { 5,7,6,3,8};
                //调用选择排序的方法
                selectSort(array);
                //调用Arrays工具类的toString方法,将数组内容以字符串形式进行输出
            System.out.println(Arrays.toString(array));
        }
        //定义选择排序,参数为int型数组,将传入的数组按从小到大排好
        public static void selectSort(int[] array){ 
            //初始化最小值的索引为0
            int min = 0;
            for (int i = 0; i < array.length-1; i++) { 
                //每趟排序让min的索引值都等于本趟排序的i值
                min = i;
                for (int j = i+1; j < array.length; j++) { 
                    //如果发现了比array[min]小的值,就将这个值的索引值赋值交给min
                     if(array[min]>array[j]){ 
                         min = j;
                     }
                }
                //执行完一趟排序的所有比较后,判断这个最小值的索引值和i值是否相同
                //不相同则说明此min索引值的值不是最小值,因此发生交换
                if(i!=min){ 
                //调用交换方法
                    exchange(array,i,min);
                }
            }
        }
        //定义交换方法,让数组中的两个元素的值交换
        public static  void exchange(int[]array,int a,int b){ 
             int temp = array[a];
             array[a] = array[b];
             array[b] = temp;
        }
    }

程序运行结果

[3, 5, 6, 7, 8]

# 冒泡排序 #

*  基本思想:
 *  对(待排序)的序列从前向后，依次比较相邻的值，如果发生逆序就交换，这样比较大的数就会从前向后移，就像是水泡浮上水面。
 *  个人解释:最多进行数组的长度减1趟排序，每一趟排序中对相邻的两个数值进行比较，如果发现逆序情况(即左边的数大于右边的数),让这两个值发生交换,每一趟排序都会至少确定一个最大的值放在最右侧。遍 历了一遍数组后，如果没有发生交换，则说明本数组已经是排序完成的状态，则终止本次冒泡排序。

import java.util.Arrays;
    public class Test { 
        public static void main(String[] args) { 
                int[] array = { 31,22,78,66,55};
                //调用冒泡排序方法
               bubbleSort(array);
               //调用Arrays工具类的toString方法,将数组内容以字符串形式进行输出
            System.out.println(Arrays.toString(array));
        }
        //定义冒泡排序
        public static void bubbleSort(int[]array){ 
            //定义标识符flag,用来判断下一趟排序用不用继续执行。
            //如果flag为false,说明本数组的内容已经是正序,不必继续
            boolean flag =  false;
            //外层循环,表示每一趟排序
            for (int i = 0; i < array.length-1; i++) { 
                //内存循环,表示每一趟排序中的每一次比较
                for (int j = 0; j < array.length-i-1; j++) { 
                     if(array[j]>array[j+1]){ 
                         //至少发生了一次交换,都会让flag的值为true
                         flag = true;
                         //调用交换方法
                         exchange(array,j,j+1);
                     }
                }
                if(flag == false){ 
                     break;
                }else { 
                    //初始化flag状态,意思就是说下一次排序还是待执行的排序,让程序继续执行
                    flag = false;
                }
            }
        }
        //定义交换方法,让数组中的两个元素的值交换
        public static  void exchange(int[]array,int a,int b){ 
            int temp = array[a];
            array[a] = array[b];
            array[b] = temp;
        }
    }

程序运行结果

[22, 31, 55, 66, 78]

# 插入排序 #

*  基本思想:  
    把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较。将它插入到有序表的适当位置,使之成为新的有序表。
 *  个人解释:  
    将一个数组划分为两个表，一个有序，一个无序。每次排序都是从无序表中拿出来一个数据，与有序表中的数据逐个比较，找到自己的位置，新的有序表就诞生了，以此类推。

import java.util.Arrays;
    public class Test { 
        public static void main(String[] args) { 
                  int [] array = { 44,33,77,66};
                  //调用插入排序
                  insertSort(array);
                  //调用Arrays工具类的toString方法,将数组内容以字符串形式进行输出
            System.out.println(Arrays.toString(array));
        }
        //定义插入排序
        public static void insertSort(int[] array){ 
        //外层循环,从0开始,遍历整个数组
            for (int i = 0; i < array.length; i++) { 
            //内存循环,从i开始,i之前的序列为有序序列
            //j>0是因为j最小指到0
            //j从第2个元素开始在有序表中插入
            //满足array[j-1]>array[j],循环会一直进行,直到待插入数据找到自己的位置
            //j--是将待插入数据在有序表中向前逐个比较，知道找到自己的位置
                for (int j = i; j >0 ; j--) { 
                if(array[j-1]>array[j]){ 
                //调用交换方法
                    exchange(array,j,j-1);
                    }
                }
            }
        }
        //定义交换方法,让数组中的两个元素的值交换
        public static  void exchange(int[]array,int a,int b){ 
            int temp = array[a];
            array[a] = array[b];
            array[b] = temp;
        }
    }

程序运行结果

[33, 44, 66, 77]

# 练习 #

## 练习1 ##

*  题目:使用switch-case实现给定一个分数，根据分数确定等级:优秀(90分及以上)良好(80分及以上)及格(60分及以上)不及格(60分以下)

import java.util.Scanner;
    /* 题目:使用switch-case实现给定一个分数， 根据分数确定等级:优秀(90分及以上)良好(80分及以上)及格(60分及以上)不及格(60分以下) */
    public class Test { 
        public static void main(String[] args) { 
          Scanner sc = new Scanner(System.in);
          int grade = sc.nextInt();
          switch(grade/10){ 
              case 10:
              case  9:
                  System.out.println("优秀");break;
              case  8:
                  System.out.println("良好");break;
              case  7:
              case  6:
                  System.out.println("及格");break;
              default:
                  System.out.println("不及格");break;
          }
        }
    }

*  程序运行结果视输入的数字而定  
    例如我们输入88

输入:88
    良好

## 练习2 ##

*  题目:分别用while和do-while实现1到100这100个数字的和

### while ###

public class Test { 
        public static void main(String[] args) { 
              int i = 1;
              int sum = 0;
              while(i<=100){ 
                  sum = sum + i;
                  i++;
              }
            System.out.println(sum);
        }
    }

### do-while ###

public class Test { 
        public static void main(String[] args) { 
              int i = 1;
              int sum = 0;
             do{ 
               sum = sum + i;
               i++;
             }while(i<=100);
            System.out.println(sum);
        }
    }

## 练习3 ##

*  题目:使用continue关键字完成对1到5这5个数字中奇数的筛选 输出奇数

public class Test { 
        public static void main(String[] args) { 
            for (int i = 1; i <= 5; i++) { 
                if(i%2==0){ 
                    continue;
                }
                System.out.println(i);
            }
        }
    }

程序运行结果

1
    3
    5

## 练习4 ##

*  题目:使用break关键字对1-5的筛选，筛选出第一个偶数2

public class Test { 
        public static void main(String[] args) { 
            for (int i = 1; i < 5; i++) { 
                if(i%2==0){ 
                    System.out.println(i);
                    break;
                }
            }
        }
    }

*  程序运行结果

## 练习5 ##

*  题目:“百钱买百鸡”是我国古代的著名数学题。题目这样描述：3 文钱可以买1只公鸡，2 文钱可以买一只母鸡，1 文钱可以买3 只小鸡。用100 文钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？

public class Test { 
        public static void main(String[] args) { 
            //cock hen chick 分别对应公鸡 母鸡 小鸡
            int cock = 0;
            int hen = 0;
            int chick = 0;
            //全买公鸡
            for ( cock = 0; cock < 100/3; cock++) { 
                //减去公鸡后，剩下全买母鸡
                for (  hen = 0; hen < (100-cock*3)/2; hen++) { 
                    //剩下全是小鸡
                     chick = 100 - cock - hen;
                     //限制条件:小鸡的数量必须被3整除 并且3种鸡的总价为100
                     if(chick%3==0 && cock*3 + hen*2 + chick/3 ==100){ 
                         System.out.println("公鸡:"+cock+" 母鸡:"+hen+" 小鸡:"+chick);
                     }
                }
            }
        }
    }

程序运行结果

公鸡:0 母鸡:40 小鸡:60
    公鸡:5 母鸡:32 小鸡:63
    公鸡:10 母鸡:24 小鸡:66
    公鸡:15 母鸡:16 小鸡:69
    公鸡:20 母鸡:8 小鸡:72
    公鸡:25 母鸡:0 小鸡:75

## 练习6 ##

*  题目:搬砖问题：36 块砖，36 人搬，男搬4，女搬3，两个小孩抬1 砖，要求一次全搬完，问男、女和小孩各若干？

public class Test { 
        public static void main(String[] args) { 
          //man woman child分别对应 男人 女人 小孩
            int man = 0;
            int woman = 0;
            int child = 0;
            //全是男人
            for ( man = 0; man < 36/4; man++) { 
                //减去男人后，剩下全是女人
                for ( woman = 0; woman < (36-man*4)/3; woman++) { 
                //剩下全是小孩
                    child = 36 - man - woman;
                    //限制条件:小孩的数量必须被2整除 并且3种人搬的砖总数为36
                    if(child%2==0 && man*4 + woman*3 +child/2==36){ 
                        System.out.println("男:"+man+" 女:"+woman+" 小孩:"+child);
                    }
                }
            }
        }
    }

程序运行结果

男:3 女:3 小孩:30

## 练习7 ##

*  题目:编程找出四位整数abcd 中满足下述关系的数。(ab+cd)(ab+cd)=abcd  
    例如 (20+25)\*(20+25)=2025

public class Test { 
        public static void main(String[] args) { 
            for (int i = 1000; i <10000; i++) { 
                int ab = i/100;
                int cd = i%100;
                if((ab+cd)*(ab+cd)==i){ 
                    System.out.println(i);
                }
            }
        }
    }

程序运行结果

2025
    3025
    9801

## 练习8 ##

*  题目:求水仙花数。所谓水仙花数，是指一个三位数abc，如果满足a3+b3+c3=abc，则abc 是水仙花数。  
    例如:1的3次方+5的三次方+3的3次方=153

public class Test { 
        public static void main(String[] args) { 
            for (int i = 100; i < 1000; i++) { 
                int a = i/100;
                int b = i/10 %10;
                int c = i%10;
                if(a*a*a+b*b*b+c*c*c==i){ 
                    System.out.println(i);
                }
            }
        }
    }

程序运行结果

153
    370
    371
    407

## 练习9 ##

*  题目:输入一个整数，计算它各位上数字的和。(此数为任意位的数)

import java.util.Scanner;
    /* 题目:输入一个整数，计算它各位上数字的和。(此数为任意位的数) */
    public class Test { 
        public static void main(String[] args) { 
            //创建Scanner类对象
                 Scanner sc = new Scanner(System.in);
                 int number = sc.nextInt();
            System.out.println("输入的值为:"+number);
            //定义各位数字和为sum
            int sum = 0;
            while(number!=0){ 
                //总和每次加的都是当前的最后一位
                  sum = sum +  number%10;
                  //输入的整数每次循环都少一位
                  number /= 10;
            }
            System.out.println("该数各位总和为:"+sum);
        }
    }

程序运行结果视输入情况而定，例如我们输入123和1234

(1)输入123
    输入的值为:123
    该数各位总和为:6
    (2)输入1234
    输入的值为:1234
    该数各位总和为:10

## 练习10 ##

*  题目:使用for循环打印九九乘法表

public class Test { 
        public static void main(String[] args) { 
            for (int i = 1; i < 10; i++) { 
                for (int j = 1; j <= i; j++) { 
                    int result = i*j;
                    System.out.print(i+"X"+j+"="+result+" ");
                }
                System.out.println();
            }
        }
    }

程序运行结果

1X1=1 
    2X1=2 2X2=4 
    3X1=3 3X2=6 3X3=9 
    4X1=4 4X2=8 4X3=12 4X4=16 
    5X1=5 5X2=10 5X3=15 5X4=20 5X5=25 
    6X1=6 6X2=12 6X3=18 6X4=24 6X5=30 6X6=36 
    7X1=7 7X2=14 7X3=21 7X4=28 7X5=35 7X6=42 7X7=49 
    8X1=8 8X2=16 8X3=24 8X4=32 8X5=40 8X6=48 8X7=56 8X8=64 
    9X1=9 9X2=18 9X3=27 9X4=36 9X5=45 9X6=54 9X7=63 9X8=72 9X9=81