流程控制
顺序结构
package com.chen.struct;
public class ShunXuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
System.out.println("hello5");
}
}
选择结构
一、while语句
package com.chen.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1~100
int i = 0;
while (i<100){
i++;
System.out.println(i);
}
}
}
package com.chen.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//死循环
while (true){
//等待客户端连接
//定时检查
//......
}
}
}
package com.chen.struct;
public class WhileDemo03 {
public static void main(String[] args) {
//计算1+2+3+...+100=?
//数学家高斯的故事
//数字
int i = 0;
//和
int sum = 0;
while (i<=100){
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
二、do...while...语句
package com.chen.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
//计算1+2+3+...+100=?
int i = 0;
int sum = 0;
do {
sum = sum + i;
i++;
}while (i <= 100);
System.out.println(sum);
}
}
package com.chen.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a = 0;
//while先判断后执行
while (a < 0){
System.out.println(a);
a++;
}
System.out.println("========================");
//do...while先执行后判断，并且保证循环体会被至少执行一次
do {
System.out.println(a);
a++;
}while (a<0);
}
}
三、switch语句
package com.chen.struct;
public class SwitchDemo01{
public static void main(String[] args) {
//case穿透
//switch：匹配一个具体的值
char grade = 'C';
switch (grade){
case 'A':
System.out.println("优秀");
break; //可选
case 'B':
System.out.println("良好");
break; //可选
case 'C':
System.out.println("及格");
//break; //可选
case 'D':
System.out.println("再接再厉");
//break; //可选
case 'E':
System.out.println("挂科");
//break; //可选
default:
System.out.println("未知等级");
}
}
}
package com.chen.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "晨晨";
//JDK7的新特性，表达式结果可以是字符串！！！
//字符的本质还是数字
//反编译 java---->class(字节码文件) ---->反编译(IDEA)
switch (name){
case "晨晨":
System.out.println("晨晨");
break;
case "晨曦":
System.out.println("晨曦");
break;
default:
System.out.println("干啥勒！");
}
}
}
四、if语句及if...else语句
package com.chen.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容：");
String s = scanner.nextLine();
//equals：判断字符串是否相等
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
package com.chen.struct;
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
//考试分数大于60分就是及格，小于60分就不及格。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
scanner.close();
}
}
package com.chen.struct;
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
//考试分数大于60分就是及格，小于60分就不及格。
Scanner scanner = new Scanner(System.in);
/*
if 语句至多有一个else语句，else语句在所有的else if语句之后；
if 语句可以有若干个else if语句，它们必须在else语句之前；
一旦其中一个else if 语句检测为true，其他的 else if 以及 else 语句都将跳过执行。
*/
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score==100){
System.out.println("满分，再接再厉！");
}else if (score<100 && score>=90){
System.out.println("A级");
}else if (score<90 && score>=80){
System.out.println("B级");
}else if (score<80 && score>=70){
System.out.println("C级");
}else if (score<70 && score>=60){
System.out.println("D级");
}else if (score<60 && score>=0){
System.out.println("不及格");
}else{
System.out.println("成绩不合法");
}
scanner.close();
}
}
循环结构
一、for循环
package com.chen.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1; //初始化条件
while (a<=100){ //条件判断
System.out.println(a); //循环体
a+=2; //迭代
}
System.out.println("while循环结束！");
//初始化值 //条件判断 //迭代
for (int i=1;i<=100;i++){
System.out.println(i);
}
System.out.println("for循环结束！");
/*
关于for 循环的说明：
1.最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
2.检测布尔表达式的值。如果为true,循环体被执行；为false，循环终止，开始执行循环体后面的语句。
3.执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
4.再次检测布尔表达式。
5.循环执行上面的全过程。
*/
//死循环
for (; ; ){
}
}
}
二、练习1
package com.chen.struct;
public class ForDemo02 {
public static void main(String[] args) {
//练习1：计算0~100之间的奇数和偶数的和
int oddSum = 0;
int evenSum = 0;
for (int i = 0; i <= 100; i++) {
if (i%2!=0){ //奇数
oddSum+=i; //oddSum = oddSum + i;
}else{ //偶数
evenSum+=i;
}
}
System.out.println("奇数的和："+oddSum);
System.out.println("偶数的和："+evenSum);
}
}
三、练习2
package com.chen.struct;
public class ForDemo03 {
public static void main(String[] args) {
//练习2：用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i+"\t");
}
if (i%(5*3)==0){ //
System.out.println();
//System.out.print("\n");
}
}
//printLn 输出完会换行
//print 输出完不会换行
}
}
四、九九乘法表
package com.chen.struct;
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
public class ForDemo04 {
public static void main(String[] args) {
//打印九九乘法表
//1.先打印第一列
//2.再把固定的1用一个循环包起来
//3.去掉重复项，i <= j;
//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循环遍历数组元素
package com.chen.struct;
public class ForDemo05 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50}; //定义了一个数组
for (int i = 0;i<5;i++){
System.out.println(numbers[i]);
}
System.out.println("=====================");
//遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
}
}
Break & Continue
一、打印三角形
package com.chen.struct;
public class TestDemo {
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();
}
}
}
二、break
package com.chen.struct;
public class BreakDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break; //break用于强行退出循环
}
}
System.out.println("123456");
}
}
三、continue
package com.chen.struct;
public class ContinueDemo {
public static void main(String[] args) {
int i = 0;
while (i<100){
i++;
if (i%10==0){
System.out.println();
continue;
}
System.out.print(i);
}
//break在任何循环语句的主体部分，均可用break控制循环的过程
//break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
//continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
}
}
四、goto关键字
package com.chen.struct;
public class LabelDemo {
public static void main(String[] args) {
//打印101~150之间所有的质数
//质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数
int count = 0;
//不建议使用goto保留字
outer:for (int i = 101; i < 150; i++){
for (int j = 2; j < i/2; j++){
if (i % j == 0){
continue outer;
}
}
System.out.print(i+" ");
}
}
}
Method
一、方法定义
package com.chen.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
//实际参数：实际调用传递给它的参数
int sum = add(1,2);
System.out.println(sum);
//test(); //test()方法调用
}
//加法
//形式参数，用来定义作用的
public static int add(int a, int b){
return a+b;
}
public static void test(){
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i+"\t");
}
if (i%(5*3)==0){ //
System.out.println();
//System.out.print("\n");
}
}
}
}
二、java都是值传递
package com.chen.method;
//java 都是值传递
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;
if (num1==num2){
System.out.println("num1==num2");
return 0; //终止方法
}
if (num1>num2){
result = num1;
}else{
result = num2;
}
return result;
}
}
三、方法的重载
package com.chen.method;
//方法的重载
public class Demo03 {
public static void main(String[] args) {
int max = max(10,20,30);
System.out.println(max);
}
//比大小
public static double max(double num1,double num2,double num3){
double result = 0;
if (num1==num2){
System.out.println("num1==num2");
return 0; //终止方法
}
if (num1>num2 && num1>num3){
result = num1;
}else if(num1<num2 && num3<num2){
result = num2;
}else{
result = num3;
}
return result;
}
//比大小
public static int max(int num1,int num2){
int result = 0;
if (num1==num2){
System.out.println("num1==num2");
return 0; //终止方法
}
if (num1>num2){
result = num1;
}else{
result = num2;
}
return result;
}
//比大小
public static int max(int num1,int num2,int num3){
int result = 0;
if (num1==num2){
System.out.println("num1==num2");
return 0; //终止方法
}
if (num1>num2 && num1>num3){
result = num1;
}else if (num2>num1 && num2>num3){
result = num2;
}else{
result = num3;
}
return result;
}
}
四、数组长度
package com.chen.method;
public class Demo04 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
}
五、调用可变参数的方法
package com.chen.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 void printMax(double... numbers){
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("The max value is " + result);
}
}
六、递归
package com.chen.method;
public class Demo06 {
//学习递归思想
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);
}
}
}
数组
package com.chen.array;
public class ArrayDemo01 {
//变量的类型 变量的名字 = 变量的值
//数组类型
public static void main(String[] args) {
int[] nums; //1.声明一个数组
nums = new int[10]; //2.创建一个数组
//int[] nums = new int[10];
//3.给数组中的元素赋值
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;
//获取数组的长度：arrays.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为：" + sum);
}
}
二、静态初始化
package com.chen.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] = 10;
b[1] = 10;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);
}
}
三、数组的运用
package com.chen.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//打印全部的数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("================");
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
System.out.println("sum="+sum);
System.out.println("=================");
//查找最大元素
int max = arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (arrays[i]>max){
max = arrays[i];
}
}
System.out.println("max="+max);
}
}
四、反转数组
package com.chen.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
//JDK1.5，没有下标
//for (int array : arrays) {
// System.out.println(array);
//}
printArray(arrays);
System.out.print("=====================");
int[] reverse = reverse(arrays);
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]; //length为4时，result的值为5，因此下面j的长度需要减1
//反转操作
for (int i = 0, j=result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
}
五、二维数组
package com.chen.array;
public class ArrayDemo05 {
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]);
printArray(array[0]);
System.out.println(array[0][0]);
System.out.println(array[0][1]);
System.out.println(array.length);
System.out.println(array[0].length);
*/
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]+" ");
}
}
}
六、数组填充
package com.chen.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,4,9090,31231,543,21,3,23};
System.out.println(a); //结果[I@1b6d3586是一个哈希code的对象。
//打印数组元素 Arrays.toString
//System.out.println(Arrays.toString(a));
//printArray(a);
Arrays.sort(a); //数组进行排序：默认升序排序
System.out.println(Arrays.toString(a));
//数组填充
Arrays.fill(a,2,4,0); //下标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==a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i]+", ");
}
}
}
}
七、冒泡排序
package com.chen.array;
//冒泡排序： 该事件算法的时间复杂度为 O(n^2)
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
//2.每比较一次，都会产生出一个最大或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束!!! ----->3个杯子，借助第三个容器暂存中转的思想
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,3,5,7,2,21,3,11,9};
int[] sort = sort(a); //调用完自己写的排序方法后，返回一个排序后的数组
System.out.println(Arrays.toString(a));
}
/* 线程池
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
*/
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;
}
}
if (flag==false){
break;
}
}
return array;
}
}
八、稀疏数组
package com.chen.array;
public class ArrayDemo08 {
public static void main(String[] args) {
//！！！思想： 二维横、纵坐标，以及值的个数
//1.创建一个二维数组 11行 * 11列 0：没有棋子，1：黑棋，2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("输出原始的数组");
/*new Thread(() -> {
System.out.println();
}).start();
*/
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;
//遍历二维数组，将非零的值，存放到稀疏数组中
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");
}
System.out.println("====================");
System.out.println("还原稀疏数组：");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
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();
}
}
}
