001.Java基础 ——程序流程控制和数组基础
顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构
根据条件，选择性地执行某段代码。 有if…else和switch两种分支语句。
循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
// 1.导包
import java.util.Scanner;
class TestScanner{
public static void main(String[] agrs){
// 2.创建一个Scanner类的对象
Scanner s = new Scanner(System.in);
System.out.println("请输入一个字符串");
// 3.调用此对象的相应的方法，完成键盘输入的值的获取
//=> next():表示从键盘获取一个字符串
String str = s.next();
System.out.println(str);
}
}
条件语句总结：
1.条件判断之间可以嵌套
2.①如果多个条件之间是“互斥”关系（即条件之间没有联系，没有公共部分），多个条件语句上下的顺序是自由的
②如果多个条件之间存在“包含”关系，要求范围小的要写在范围大的上面
说明：如果 if-else if-else条件的执行语句块{}只有一条语句的话，那么这一对{}可以省略，但是建议不要省略
switch语句
/*
switch(变量){
case 值1：
case 值2：
case 值3：
default:
}
1.根据变量的值，选择相应的case去判断，一旦满足case条件，就执行case的相应语句。如果没有break或者已经到结尾的话，就会继续执行其下的case语句。
2.default：是可选的（可写，可不写），而且位置是灵活的
3.变量可以是哪些类型？char byte shor int 枚举 string(jdk1.7 以后的版本才可以放string类型的变量)
4.case 条件：其中条件只能是值，不能是取值范围
*/
package com.base.java;
public class TestSwitch1 {
public static void main(String[] args ){
int i = 2;
switch (i){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
break; //=> default 是结构比较灵活，可以放在其他位置，但是习惯上写在最后，为了保险起见也加一个break
}
}
}
习题与注意事项：
package com.base.java;
/*
习题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：当多个case语句处理的语句块一致时，可以统一的来书写。
习题：根据用于指定月份，打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季，同理用下面这种方法
*/
public class TestSwitch02 {
public static void main(String[] args){
int score = 67;
switch (score/10){
case 10:
case 9:
case 8:
case 7:
case 6:
System.out.println("及格");
break;
default:
System.out.println("不及格");
}
}
}
无限循环：
for(;;){}
while(true){}
说明：在无限循环内部，要有条件终止的语句，使用break，若没有，那就是死循环。
练习：
// 100以内的质数（素数） 质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。
package com.base.java;
public class TestPrimeNumber {
public static void main(String[] args) {
boolean flag = false;
long start = System.currentTimeMillis();
for (int i = 2; i <= 100000; i++) {
for (int j = 2; j <= Math.sqrt(i); j++) { // j < i; 中的i改成 Math.sqrt(i)
if (i % j == 0) {
flag = true;
break;
}
}
if (!flag) {
System.out.println(i);
}
flag = false;
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start)); // 23609,+break 提升了10倍速度 2356 ,i改成Math.sqrt(i) 速度为 190
}
}
break and continue
//=> 设置break标签，决定跳出哪层循环
public class BreakContinue {
public static void main(String[] args) {
lable: //=> 设置跳出标签 lable
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 10; j++) {
if (j % 4 == 0) {
break lable; // continue lable continue 也可以用标签
// System.out.println("永远不执行，还会报错"); continue 和 break 下面跟着的语句不会执行
}
System.out.print(j); // 123
}
}
}
}
输出十万以内质数的第二种写法
// 输出十万以内质数的第二种写法，这个写法运用到了跳出循环的标签设置，修改后的代码如下
public class TestPrimeNumber {
public static void main(String[] args) {
// boolean flag = false;
long start = System.currentTimeMillis();
lable:for (int i = 2; i <= 100000; i++) {
for (int j = 2; j <= Math.sqrt(i); j++) { // j < i; 中的i改成 Math.sqrt(i)
if (i % j == 0) {
// flag = true;
// break;
continue lable;
}
}
//if (!flag) {
System.out.println(i);
//}
//flag = false;
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start)); // 23609,+break 提升了10倍速度 2356 ,i改成Math.sqrt(i) 速度为 190
}
}
练习输出1000以内的完数
//1000以内的完数，完数是除了它本身，其他约数的和等于它的数，比如：6 = 1 + 2 + 3
public class YinShu {
public static void main(String[] args) {
int current = 0;
for (int i = 1; i < 1000; i++) {
for (int j = 1; j < i; j++) {
if (i % j == 0) {
current += j;
}
}
if (current == i) {
System.out.println(i);
}
current = 0; // 这里要注意
}
}
}
数组
public class TestArray {
public static void main(String[] args){
// 1.如何定义一个数组
// 1.1数组的声明
String[] names;
int[] scores;
// 1.2初始化
//第一种：静态初始化：初始化数组与给数组元素赋值同时进行
names = new String[]{"Sam", "Daniel", "Jim"};
//第二种：动态初始化：初始化数组与给数组元素赋值分开进行
scores = new int[4];
//2.如何调用相应的数组元素：通过数组元素的下角标的方式来调用
//下角标从0开始，到n-1结束，其中n表示数组长度。
scores[0] = 88;
scores[1] = 58;
scores[2] = 98;
scores[3] = 68;
// 3.数组的长度，通过数组的length属性。
System.out.println(names.length); // 3
System.out.println(scores.length); // 4
// 4.如何遍历数组元素
for(int i = 0; i < name.length; i++){
System.out.println(names[i]);
}
}
}
数组元素的默认初始化值
public class TestArray {
public static void main(String[] args) {
String[] strs = new String[4];
strs[0] = "AA";
strs[1] = "BB";
// strs[2] = "CC"; //=>如果有一项没有赋值，则遍历的时候会出现null
strs[3] = "DD";
// 遍历数组
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
// 对于基于基本数据类型的变量创建的数组：byte,char,short,int,long,float.double,boolean
// 1.对于byte short int long 而言：创建数组以后，默认值为0
// 2.对于float double而言，默认值是0.0
// 3.对于char而言，默认的为空格
// 4.对于boolean而言，默认为false
// 5.对于引用类型的变量构成的数组而言，默认初始化值为null。以String为例
}
}
注意：数组一旦初始化，其长度是不可变的。只能重新定义个数组，并且先把之前的数组值拷贝过来，再添加所需要的内容。
多维数组的使用
package com.java.base;
public class TestArray {
public static void main(String[] args) {
int[] scores1 = new int[10];
int[] scores2;
String[][] names;
// 1.二维数组的初始化
scores2 = new int[][]{{1,2,3},{4,5,6},{6}}; // 静态初始化
names = new String[6][5]; // 动态初始化的方式一
names = new String[6][]; // 动态初始化的方式二
names[0] = new String[5];
names[1] = new String[4];
names[2] = new String[9];
names[3] = new String[5];
names[4] = new String[2];
names[5] = new String[8];
// 错误的初始化方式
// names = new String[][]; 什么都没写是错的
// names = new String[][5]; 前面没有后面有是错的
// 2.若何来引用具体的某一个元素
int[][] i = new int[3][2]; // 另一种写法int[] i[] = new int[3][2]; 一样的
i[1][0] = 90;
i[2][1] = 100;
// 3.关于数组的长度
// 二维数组的长度，length属性
System.out.println(i.lenght);
// 二维数组中元素的长度
System.out.println(i[0].lenght);
// 4.如何遍历二维数组（嵌套for循环）
for(int m =0; m < scores2.length; m++){
for(int n = 0; n < scores2[m].length; n++){
System.out.println(scores2[m][n]);
}
}
}
}
数组的常见异常：越界
public class TestArray {
public static void main(String[] args) {
// 1.数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
i[0] = 100;
// i[10] = 98; //=>这里的下标为10，则数组长度却为11，因此越界
for (int j = 0; j <= i.length; j++) { // 此处如果是有“=”号，则又是越界，长度多1个
System.out.println(i[j]);
}
}
}
数组的常见异常：空指针错误异常
public class TestArray {
public static void main(String[] args) {
// 2.空指针异常：java.lang.NullPointerException
// 第一种：
boolean[] b = new boolean[3];
b = null; // 此处将引用数据类型设置为null，指针就消失了，下面在b[1]访问数组会报错
System.out.println(b[1]);
// 第二种：
String[] str = new String[4];
System.out.println(str[3].toString()); // new之后的数组并没有赋值，这时候选择某个元素，则为null，再调用方法就是报错，空指针异常
// 第三种：二维数组的
int[][] j = new int[3][];
j[2][0] = 12; // 这里是没有给 j[2]赋值，则j[2]是null，所以null没法指向[0]这里
}
}
注意：
int[] x, y[];
// 相当于
// int[] x; //=> 声明一个一维数组
// int[] y[]; //=> 声明一个二维数组
x = y[];这种赋值是可以通过的，因为x是一维数组，y[]也是一个一维数组
数组的写法（以下写法都可以）：
一维数组：int[] x 或者 int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
数组中涉及的常见算法
// 数组中涉及的常见算法
/*
* 1.求数组的最大值，最小值，平均数，总和等
* 2.数组的复制、反转
* 3.数组元素的排序
* */
public class TestArray3 {
public static void main(String[] args) {
int[] ary = new int[]{5, 21, 99, 2, 19, 6, 81, 19};
// 求最大值
int max = ary[0];
for (int i = 0; i < ary.length; i++) {
if (max < ary[i]) {
max = ary[i];
}
}
System.out.println(max);
// 求最小值
// 求总和
// 求平均数
// 比较简单，先不写了
}
}
