一，分支（选择）结构

一，语法

1，单分支

//获取判断条件逻辑 start
Scanner input= new Scanner(System.in);
System.out.println("请输入张浩同学的java成绩");
int iJavas = input.nextInt();
System.out.println("请输入张浩同学的音乐成绩");
int iMusics = input.nextInt();
//获取判断条件逻辑 end
//给一个初始默认值
String sReturn = "老师不奖励他";//根据逻辑：
//张浩Java成绩大于90分，并且音乐成绩大于80分时，
//或者java乘积等于100分，音乐成绩大于70分时
//老师奖励他
//进行if语句编写
if((iJava>90 && iMusics>80)||(iJavas==100 && iMusics>70)){sReturn = "老师奖励被咬了一口的apple6";
}//输出结果
System.out.println(sReturn);

2，双分支

//获取判断条件逻辑 start
Scanner input = new Scanner(System.in);
System.out.println("请问六子吃了几碗粉：");
int num1 = input.nextInt();
System.out.println("请问刘子付了几碗钱");
int num2 = input.nextInt();
//获取判断条件逻辑 end//开始判断
if(num1 == num2){//满足条件System.out.println("这就是公平！！！");
}else{//不满足条件System.out.println("你这不是欺负老实人吗？！！");
}

3，多分支

//获取判断条件逻辑 start
Scanner input = new Scanner(System.in);
System.out.prinln("请输入你的成绩：");
int i= input.nextInt();
String sReturn = "";
//获取判断条件逻辑 end//进行判断
if(i>=80){sReturn = "良好";
}else if(i>=60){sReturn = "中等";
}else{sReturn = "差";
}
System.out.println("你本次的结果为："+sReturn);

4，嵌套分支

//由于if(){}else{}的逻辑如下
if(true){//代码
}else{//代码
}
//而且if(){}else{}本质也是代码，所以他自然可以嵌套在其他的if(){}else{}当中//如下实例:
String sReturn= "";
if(score>10){sReturn = name+"同学，很遗憾你无缘参加决赛";
}else{if("男".equals(sex)){sReturn = "恭喜你"+name+ "进入男生组决赛";}else{sReturn = "恭喜你"+name+ "进入女生组决赛";}
}
System.out,println(sReturn);

二，switch

Scanner input = new Scanner(System.in);
System.out.println("请输入你获得的名次：");
int mingCi = input.nexInt();
switch(mingCi){case 1:System.out.printlnl("恭喜你获得第一名");//如果不用break跳出，会继续执行之后的每一个case选项break;case 2:System.out.printlnl("恭喜你获得第二名");break;default:System.out.printlnl("谢谢参与");}
//关于default
//default的位置是存在讲究的，一般情况下，我们会将default放在switch的最后一块
//如果所有的case都匹配不上，则会进匹配default当中
//如果进入某个case块（包括default） 那么， 当没有遇到break的时候
//会将该位置之后的所有case块（包括default）按照顺序执行//比如你的代码如下：
switch(mingCi){case 1:System.out.printlnl("恭喜你获得第一名");//如果不用break跳出，会继续执行之后的每一个case选项 default:System.out.printlnl("谢谢参与");case 2:System.out.printlnl("恭喜你获得第二名");
}
//当mingCi为1的时候会执行24 28 30行代码
//当mingCi为2的时候会进入顺序执行30（因为有case匹配，所以不进default）
//当mingCi为3的时候只会执行28 30（因为所有的case都匹配不上，所以进入default）
//存在break，那么28及之后的30行都会被执行

给一个不需要break的场景例子

Scanner input = new Scanner(System.in);
int iCount = 0;
System.out.println("每过一个小时给计时器+1");
System.out.printlnl("现在是几点");
String time = input.next();
switch(time){case "20:00":iCount++;case "21:00":iCount++;case "22:00":iCount++;case "23:00":iCount++;
}
System.out.println("过"+iCount+"小时是24:00");

三，String的equals方法

对于字符串的比较我们不是用== 而使用equals方法调用，比如

String str="str";
if("str".equals(str)){//执行代码
}

当我们对于一个字符串对象和一个字符串比较时，如上图的str对象和”str“字符串比较

我们一定要将字符串”str“写在前面，否则当str对象为null（空）时，会抛出

NullPointerException——空指针异常

四，局部变量

//当我们声明的变量在某块代码块中，而不是全局
//此时该变量为局部变量，在声明的代码块以外的地方
//是无法调用或者修改该变量的
/例如：public static void main(String[] args){int i = 1;if(i>10){//此时的j为if代码块中的局部变量，无法在if模块以外使用(作用范围在7-8行中)int j=2;}//由于变量i是在main方法中声明，所以所有main方法中的代码都可以使用/修改i变量System.out.println(i);//由于变量j是在if代码块中声明，所以j只能作用在if代码块中（8-9行）在15行打印会直接报错//报j变量违背声明System.out.println(j);
}

2，循环结构

1，while循环

//循环变量声明和初始化；
while(循环条件){//循环操作！//循环变量的变化：【注意】//循环体（语句块）；//循环变量的变化：【注意】
}

2，do-while循环

特点：先执行，再判断

例如：

package com.kgc.day03;import java.util.Scanner;public class Test01 {public static void main(String[] args){//张浩同学先考试，考试完了，老师判断是否需要继续Scanner input = new Scanner(System.in);//用于判断的变量String flag="Y";do{if(!"Y".equals(flag)){System.out.println("张浩同学，你没有通过，需要重新考试");System.out.println();}System.out.println("张浩同学正在考试");System.out.println("老师 请问张浩同学是否合格，合格输入Y");flag=input.next();}while(!"Y".equals(flag));System.out.println("张浩同学你这次城通过了，可以不用再次考试");System.out.println("张浩同学通过了考试，非常开心");}
}

3，for循环

for(一号区域;二号区域;四号区域){三号区域
}
1，一号区域，写声明变量，此处为循环的最开始执行位置
2，二号区域，写循环的条件，此处为循环第二步执行的位置
3，三号区域：写循环的具体操作
4：四号区域，写变量的改变，循环具体操作结束之后我们会执行的位置
5：第二次循环开始，此时将不会在去执行一号区域内容直接进行二号区域判断
6：如果判断结果为true执行三号区域和四号区域，之后再次判断二区域如果判断结果为false将会结束循环，执行for循环之后的内容//例如for(int i=1;i<=1000;i++){System.out.println("第"+i+"遍");
}

（实际工作当中绝对不可能出现）for循环的四个区域均可以不写代码，如果你四个区域都没有写代码，那么我们发现你的这个线程卡在此处了，死循环，一直套在这里

//此时不报错，但是会一直卡住
for(;;){
}
//如果在这之后有代码会编译报错，无法执行代码
//如
System.out.println("1");
//此时第六行代码爆红，编译报错，无法编译

（实际工作当中可能出现），如果一号区域不写代码，不会影响，你可以把循环中使用的变量，放在for循环外面声明

//此时是正常输出，输出五次i的值，并且在第7行可以调用到i
//如果你的2int i0； 是写在一号区域，那么你第七行代码无法调用到i，i为for循环的局部变量
int i = 0;
for(;i<=5;i++){Systm.out.println("i");
}
Systm.out.println("你跑出了这个循环"+i);

(实际工作当中可能出现)如果二号区域不写代码，那么会将条件判断为true，会进入死循环，我们需要在三号区域中打破这个循环（使用break）

//如果不写循环条件，会视同循环条件为true，如果不存在break的情况，那么第8行代码会编译报错无法编译
for(int i=0;;i++){System.out.println(i);if(i==5){break;}
}
System.out.println("你跑出了这个循环");

（实际工作当中不会出现）如果三号区域不写代码，那么我们的for循环依旧会按照规则去执行，并且会执行四号区域逻辑

//该代码是正常运行的，并且在第六行打印的时候i的结果为6（因为i==6时才不满足条件，退出循环）
int i=0;
for(;i<=5;i++){
}
System.out.println("你跑出了这个循环"+i);

（实际工作当中不会出现）如果四号区域不写代码，那么我们可能会需要在三号区域中将该值进行调整

//该代码是正常运行的，并且在第六行打印的时候i的结果为6，（因为i==6时才不满足循环条件，退出循环）
for(int i=0;i<=5;){if(某种情况下){i++;}
}

4，break和continue

break打破本次的循环，使循环结束，执行循环之后的代码

public class Test01 {public static void main(String[] args){Scanner input = new Scanner(System.in);//声明一个可以在全局操作的变量String flag="";while(true){System.out.println("请问现在张浩同学是否合格了？如果合格输入Y");flag=input.next();if(!"Y".equals(flag)){System.out.println("张浩同学你这次没有合格，需要继续学习");System.out.println("上午阅读教材，学习理论部分");}else{
//               System.exit(0);System.out.println("恭喜你退出了循环");break;}}}
}

continue结束本次循环，进行下一次循环

package com.kgc.day03;
public class Test01 {public static void main(String[] args){int num = 0;while(num<=99){num++;//只打印奇数，如果是偶数我们呢跳过本次循环if(num%2==0){//跳过本次循环（第12行代码不执行，，但不结束循环，循环依旧会执行）continue;}System.out.println(num);}}
}

当循环，遇到break，那么就不会继续执行循环，并且不会再次进行循环条件判断

当循环，遇到continue那么就不会继续执行循环，但是会再次进行循环条件判断，如果满足继续循环

5，嵌套循环

各循环可互相嵌套

一般不超过三层

外层循环变量变化一次，内层循环变量要变化一遍

第一步是1

第二步是2

如果2判断是T，则进入4，如果是F则进入10

第三步（2为T）是4，（2为F）是10

第四步（2为T 是5

第五步（2为T 是6

第六步（6为T）是8，（6为F）是9

第七步（6为T）是7

第八步（6为T）是6

第九步（6为T）是8，（6为T）是9

第十步（6为F）3

第十一步（2为T）是4，（2为F）是10

······

二，数组

1，数组声明时内存空间存储关系

第一行是一个byte的变量

第二行时byte长度为8的数组

第三行时一个short的变量

第四行是一个长度为4的short数组

第五行是一个int的变量

第六行是一个长度为2的int数组

第七行是一个long的变量

我们的数组对象声明后会在栈内存中存储该变量，但我们存储的只是一个堆内存的引用地址

我们实际修改数组中的值是修改对应堆内存位置的值

2，什么是数组

数组本质是内存中的一串连续的空间

数组用来存储固定长度的变量的一个整体，

可以理解为

一栋楼房和一套房子的关系

tips：数组只可以存储他声明四规定的类型

概念：【一组】【类型相同的】【连续的】【存储空间的表示】

优点：

一个存储单位存多个值

空间连续（遍历）

下标（索引）定位

缺点：

长度固定

类型固定

插入和删除

3，数组的使用

package com.kgc.day05;public class Test01 {public static void main(String[] args) {String[] nameArrray;//第一步声明：数据类型【】 数组名称;nameArrray = new String[30];//第二部初始化：数组名称 = new 数据类型【长度】;nameArrray[0] = "张三";nameArrray[1] = "李四";nameArrray[2] = "王五";nameArrray[3] = "赵六";//第三步赋值：数组名称【下标】= 值;//下标取值范围：0-names.length-1//下标越界报错，数组下标越界异常System.out.println(nameArrray[2]);//第四步使用}
}

特殊方式：

1，数据类型【】数组名称 = （值1，，，值n）;

String[] nameArray={"张三","李四","王五"};

在一个数组中，如果我们使用一般的声明方式，我们会将数组的整体长度进行声明，并且将所有的值都附上默认初始值。

注意：数组初始化后所有元素都有默认无效初值

String：null

char: (char)0

int: 0

double :0.0

boolean: false

如果是使用的特殊方式，则会自动将长度变为你写入的长度，不存在默认初始值的问题

特殊方式二：

int[] scores = new int[]{89,79,76};

4，获取数组总长度

通过数组的变量名称，调用

int[] scores = new int []{89,76,79};
//可以获得数组的总长度
int i = scores.length;

5，求最大值

6，增强遍历for循环

对于数组，集合这类数据类型我们可以使用增强遍历for循环

使用语法位

for(数据类型变量名：数组名){

//正常使用该变量，如：

System.out.print(变量名);

}

7，在已经确定顺序的数列中插入一个数字

package com.kgc.day06;import java.util.Scanner;public class Test02 {public static void main(String[] args) {int[] num = new int[]{10,20,30,40,50,0};for (int i = 0; i < 6; i++) {System.out.println("intArray[" + i + "] = " + num[i]);}Scanner input = new Scanner(System.in);System.out.println("请问你要插入的数字是：");int iNum = input.nextInt();//找到插入的位置indexint index = 0;for (int i = 0; i < num.length; i++) {if (iNum < num[i]) {index = i;break;}}//往后移一位for (int j = num.length - 1; j > index; j--) {num[j] = num[j - 1];}//插入num[index] = iNum;for (int i = 0; i < 6; i++) {System.out.println("num[" + i + "] = " + num[i]);}}
}

8，java.util.Arrays常用方法

package com.kgc.day06;
import java.util.Arrays;
public class ARRAYS {public static void main(String[] args) {int a[]={20,3,32,1,72,26,35};int b[]={3,5,7,8,54,23,9};int c[]={3,5,7,8,54,23,9};System.out.println("转换前："+a);//数组转换字符串String str=Arrays.toString(a);System.out.println("转换为字符串："+str);System.out.println("");//对数组array的元素进行升序排列System.out.println("原数组："+Arrays.toString(a));Arrays.sort(a);System.out.println("排序后："+Arrays.toString(a));System.out.println("");//所以元素都赋成特定值System.out.println("赋值前："+Arrays.toString(a));Arrays.fill(a,10);System.out.println("赋值后："+Arrays.toString(a));System.out.println("");//判断两个数组是否相等(对应位置上的元素是否相等)boolean boo=Arrays.equals(a,b);boolean boo2=Arrays.equals(b, c);System.out.println("a:"+Arrays.toString(a));System.out.println("b:"+Arrays.toString(b));System.out.println("c:"+Arrays.toString(c));System.out.println("a与b是否相等？"+boo);System.out.println("b与c是否相等？"+boo2);System.out.println("");//把数组复制成特定长度的数组int d[]=Arrays.copyOf(b,b.length);System.out.println("d:"+Arrays.toString(d));System.out.println("b:"+Arrays.toString(b));System.out.println("");//查询数组下标int i=Arrays.binarySearch(b, 5);System.out.println("数组b中数字5的下标是："+i);}
}

9，二维数组

//声明
public static void main(String[] args){int[][] scores;scores=new int[5][];scores[0]=new int [13];//...//或者int [][] scores1 = new int [5][];scores1[0][0] = 1;
}

//直接声明的同时同时赋值（只能一口气把二维数组全部赋值）
int [][]scores = new int [][]{{90,85,92,78,54},{76,63,80,},{87}};
int scores[][] = {{90,85,92,78,54},{76,63,80},{87}};

//使用---我们在遍历二维数组的时候是采取的双层嵌套循环写法遍历所有的内容

关于长度（length属性）调用

三，排序

1，冒泡排序

package com.kgc.day06;import java.util.Random;
import java.util.Scanner;public class maopao {public static void main(String[] args) {Scanner input = new Scanner(System.in);int [] num = new int [7];
//        for(int i=0;i< num.length;i++){
//            System.out.println("请输入第"+(i+1)+"个数：");
//            num[i]=input.nextInt();
//        }Random r= new Random();for(int i=0;i<7;i++){num[i]=r.nextInt(50);}System.out.print("[");for(int i=0;i<7;i++){System.out.print(num[i]);if(i==num.length-1){System.out.println("]");}else{System.out.print(", ");}}boolean flag;for(int m=0;m< num.length-1;m++){flag=true;for(int n=0;n< num.length-1-m;n++){if(num[n]>num[n+1]){flag=false;int temp= num[n];num[n]=num[n+1];num[n+1]=temp;}}if(flag){break;}}System.out.println("排序后的数组为：");for (int j = 0; j < num.length; j++) {System.out.print(num[j] + "  ");}}
}

2，插入排序

for (int i = 1; i < num.length; i++) {for (int j = i - 1; j >= 0 && num[j + 1] < num[j]; j--) {int temp = num[j];num[j] = num[j + 1];num[j + 1] = temp;}}

3，选择排序

 for(int i=0;i< num.length-1;i++){int min=i;for(int j=i;j< num.length;j++){if(num[min]>num[j]){min=j;}}int temp=num[i];num[i]=num[min];num[min]=temp;}

Java基础---结构与数组与排序相关推荐

Java基础篇4——数组
Java基础篇4--数组 1.数组的概念当需要在Java程序中记录单个数据内容时,则声明一个变量即可当需要在Java程序中记录多个类型相同的数据内容时,则声明一个一维数组即可,一维数组本质上就是 ...
c 结构体在声明时赋值_Java基础知识初识Java 循环结构进阶数组数据类型各种运算符...
今天给大家带来的是初级Java基础部分的知识:包括初始Java.变量.常量.数据类型.运算符.各种选择结构.循环结构.数组等Java的基础语法部分!最后还有****循环结构的进阶****,步骤超详细, ...
Java基础语法（数组）
第4天 Java基础语法今日内容介绍 u 流程控制语句(switch) u 数组第1章流程控制语句 1.1 选择结构switch switch 条件语句也是一种很常用的选择语句,它和if条件语句 ...
java基础5 (一维)数组和二维数组
本文知识点(目录): 一维数组(一维数组的概念.优点.格式.定义.初始化.遍历.常见异常.内存分析以及常见操作(找最大值.选择排序.冒泡排序等等)) 二维数组(二维数组的遍历.排序.查找.定义 ...
Java基础5一数组的常见应用算法
常用算法 1.冒泡排序: 原理:比较两个相邻的元素,将值大的元素交换至右端示例: public static void bubbleSort(int[] a) {int n = a.length;/ ...
java字符串数组排序_在Java中对字符串数组进行排序
允许用户使用字符串数组.他们可以向数组添加字符串,从数组中删除字符串,搜索数组中的字符串,最终他们将能够对数组进行排序.分类是搞砸我的原因.我尝试过几种不同的方法.第一种方法是将数组转换为ArrayL ...
C++ STL函数结构体数组sort()排序（henu.hjy）
对于C++中sort()需要加入 #include <algorithm>该头文件 sort(首地址[必填],尾地址[必填],排序cmp函数[选填]) sort对于基本数据类型默认从小到大 ...
java基础起步五-数组（1）
·数组(array): 简单的说就是一组数. java中数组也是一种数据类型,相同数据类型的匀速按照一定的顺序的集合,而且是有限个类型相同的变量用一个名字来命名. 比如要存储1706A班级的学员成绩, ...
Java基础方法4(数组)
##6.数组操作 import java.util.Arrays; //导入java.util.Array类 public class shuzucaozuo { //替换数组中元素<通过Arr ...

Java基础---结构与数组与排序