? 程序最基本的结构，从上至下，按照程序代码的编写顺序来依次执行
java:
System.out.println("Hello");
System.out.println("World");
c:
printf("Hello \n");
printf("World \n");
选择性的执行某些代码。当条件成立时，执行一些代码，不成立时则执行另外一些代码
if(条件表达式) {
条件成立时执行的语句
}
demo:
public static void main(String[] args) {
//将大象放入冰箱
int dx = 100; //假设大象是100个单位
int bx = 80; //冰箱的最大存储单位
if (bx >= dx) {
System.out.println("将大象放入冰箱");
}
System.out.println("大象进不去冰箱");
}
if(条件表达式) {
条件满足执行的语句
}esle{
条件不成立执行的语句
}
demo
public static void main(String[] args) {
//输入一个年份
System.out.println("输入一个年份：");
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
/*
能被4整除，但不能被100整除
或者
能被400整除
*/
//判断是否为闰年
if ( ( i%4==0 && i%100 !=0 ) || ( i%400==0 ) ) {
System.out.println("闰年");
}else {
System.out.println("平年");
}
}
if(条件A) {
条件A满足执行的语句
}esle if(条件B) {
条件B成立执行的语句
}if {
以上条件都不满足执行的语句
}
demo
public static void main(String[] agrs){
Scanner sc = new Scanner(System.in);
//输入以前的工资
System.out.println("输入你目前的工资");
int oldSal = sc.nextInt();
System.out.println("输入你目前的职位【 1普工 2主管 3经理 】");
int job = sc.nextInt();
if(job == 1 ){
oldSal = oldSal+100;
}else if( job == 2){
oldSal = oldSal + 500;
}else if( job == 3 ) {
oldSal = oldSal + 1000;
}else{
System.out.println("输入有误");
}
//输出
System.out.println("调薪后您的薪水为："+oldSal);
}
在IF 的内部可以 再使用IF结构，内部的IF 外部成立才执行。
demo
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个分数");
int score = sc.nextInt();
//合法输入
if( score>=0 && score<=750 ){
//判断条件
if( score >=550 ){
System.out.println("恭喜,您的分数可以报一本院校");
}else if( score>=500 ){
System.out.println("恭喜,您的分数可以报二本院校");
}else if( score>=480 ){
System.out.println("恭喜,您的分数可以报三本院校");
}else if( score>=400 ){
System.out.println("恭喜,您的分数可以报专科院校");
}else{
System.out.println("恭喜,放牛！");
}
}else{
System.out.println("非法输入");
}
}
? 判断变量的值与case所给的值是否相等，如果相等则执行该case后的语句，一般一个cases后面配有一个break退出switch_case结构。如果都不相等，有default则执行。default可选。
case穿透
如果一个case后缺省了break，那么程序会一次向下执行，不考虑与case是否匹配，直到执行到break才退出switch_case
switch( 变量 ){
case 值A: 语句;break;
case 值B: 语句;break;
......
default: 语句;
}
demo
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("输入星期几？【1-7】");
int day = scanner.nextInt();
switch (day) {
case 1:
System.out.println("吃肉");
break;
case 2:
System.out.println("炒面");
break;
case 3:
System.out.println("米饭");
break;
case 4:
System.out.println("火锅");
break;
case 5:
System.out.println("泡面");
break;
case 6:
System.out.println("啃馍");
break;
case 7:
System.out.println("没钱了");
break;
default:
System.out.println("输入错误");
}
}
重复执行某些程序语句
while(条件表达式) {
循环执行的语句
}
条件满足时，执行循环体中的语句，语句执行完成后，再次判断条件.......，直到不满足条件时，结束循环，退出。
?
demo
public static void main(String[] args) {
//计算100以内数的和
int n = 1;
int sum = 0;
while (n <= 100) {
//吧循环变量累计到sum上
sum += n; // sum = sum + n;
n++;
}
System.out.println(sum);
// sum = 5050;
}
?
do {
循环执行语句
} while（条件表达式）;
先执行循环体，再进行条件判断，判断是否满足条件，如果满足继续执行，不满足则退出。
循环语句至少执行一次
demo
// 找出100以内，能被3整除，不能被5整除的数
public static void main(String[] args) {
int n = 0;
do {
if ( n%3==0 && n%5 != 0 ){
System.out.println(n);
}
n++;
}while (n<100);
}
?
for( 初始化变量 ; 循环条件 ;迭代 ) {
循环语句;
}
?
demo:
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//模拟错误登录三次
for (int i = 0; i < 3; i++) {
System.out.println("输入账号:");
String username = scanner.next();
System.out.println("输入密码");
String password = scanner.next();
if (username.equals("admin") && password.equals("123") ) {
System.out.println("登陆成功");
//跳出循环
break;
}else {
System.out.println("信息有误");
}
}
}
break 、 continue 、return
public static void main(String[] args) {
testBreak();
testContinue();
testReturn();
System.out.println("--主函数------------");
}
/**
* break测试方法
*/
private static void testBreak() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
break;
}
System.out.println("--break------------" + i);
}
System.out.println("--break-------for循环外-----");
}
/**
* continue测试方法
*/
private static void testContinue() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
continue;
}
System.out.println("--continue------------" + i);
}
System.out.println("--continue-------for循环外-----");
}
/**
* Return测试方法
*/
private static void testReturn() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
return;
}
System.out.println("--return------------" + i);
}
System.out.println("--return-------for循环外-----");
}
结论：
从打印可以看出：
break： 当i = 3时，执行break后，直接到for循环外，打印--break-------for循环外-----，所以break的作用是结束循环
continue： 当i = 3时，执行continue后，没有打印接下的--continue------------3，但是下一次循环还是打印了，所以continue只是结束了本次循环，
return： 当i = 3时，执行return后，不仅结束了循环，而且结束了方法，直接回到主函数了，所以return的作用是结束了所在方法的调用
总结：
return ： 作用于方法，结束当前方法，主要用来返回方法返回值，当方法有返回值的时候，返回对应类型的返回
值，没有返回值时，可以返回空，或者不返回
continue ： 作用于语法结构，结束当前方法，结束当前结构，主要用于循环的加速
break ： 作用于语法结构，作用于结构结束当前结构，主要多用于循环和switch结构中
这里说一下，我上面说的结构，是指循环体结构结构，switch结构等，不知道怎么形容了这种东西了，哈哈，感觉语法结构咋一听也不知道是什么，解释一下哈
数组是用于保存一组长度固定、类型相同的变量的集合
数组是重要的数据结构之一。
典型的线性结构（有首有尾，一对一关系，相同特性（数据类型）） 线性结构的还有：线性表、栈、队、串...
? 格式：
?
数据类型[] 数组名 = new 数据类型 [数组长度]
示例：
int arr[] = new int[10];
//定义一个长度为10的整型数组
double arr[] = new double[8];
//定义一个长度为9的double类型数组
String arr[] = new String[6];
数组是引用数据类型，占用两块空间，new关键字的作用是在堆内存里面申请连续空间。
数组也是变量，也可以先声明，再实例化
声明语法：
数据类型[] 数组名；
int[] arr;
实例化：
数组名 = new 数据类型[数组长度]
arr = new int[100];
? 数组一旦实例化，便有了下标，从0开始到length-1，如果超过下标的长度，将引发ArrayIndexOutOfBoundsException异常。数组的长度可用数组名.length来获得
?
public static void main(String[] args) {
int arr[] = new int[4];
//为数组中的每个元素赋值
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
//访问数组中的元素
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[0])
//arr[x] x的值必须小于arr.length-1.即小于4，否则java.lang.ArrayIndexOutOfBoundsException
}
数组的遍历
通常数组的元素下标是连续变化的，这一点恰好与循环联系到一起，可以使用循环的计时器来充当数组的下标，这样就可以遍历数组中的全部内容
public static void main(String[] args) {
int arr[] = new int[10];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[5] = 4;
arr[7] = 4;
arr[8] = 4;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
解决一个问题的方法可能有很多，但能称得上算法的，首先它必须能彻底解决这个问题（称为准确性），且根据其编写出的程序在任何情况下都不能崩溃（称为健壮性）。
注意，程序和算法是完全不同的概念。算法是解决某个问题的想法、思路；而程序是在根据算法编写出来的真正可以运行的代码。例如，要依次输出一维数组中的数据元素的值，首先想到的是使用循环结构，在这个算法的基础上，我们才开始编写程序。
在满足准确性和健壮性的基础上，还有一个重要的筛选条件，即通过算法所编写出的程序的运行效率。程序的运行效率具体可以从 2 个方面衡量，分别为：
程序的运行时间。
程序运行所需内存空间的大小。
根据算法编写出的程序，运行时间更短，运行期间占用的内存更少，该算法的运行效率就更高，算法也就更好。
那么，如何衡量一个算法所编写出程序的运行效率呢？数据结构中，用时间复杂度来衡量程序运行时间的多少；用空间复杂度来衡量程序运行所需内存空间的大小。
衡量一个算法的好坏就看关键的两点：时间复杂度和算法复杂度
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
时间复杂度：
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
/*
冒泡排序
使用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
*/
// [8,7,5,6,9]
public static void maoPao(int[] arr ) {
//完成逻辑排序
//控制趟数
for (int i = 0; i < arr.length; 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;
}
}
System.out.println("第“ +i+ ”趟：" + Arrays.toString(arr));
}
}
理解：
比较两个相邻的元素，将值大的元素交换到右边
思路： 依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。
(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
(2)比较第2和第3个数，将小数 放在前面，大数放在后面。
......
(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
(6)依次类推，每一趟比较次数减少依次
冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
时间复杂度/空间复杂度 ---详见数据结构
// 选择 排序：
/* {1,10,32,56,21,36,9,45,22,67,30}
* 思想： 先假设出最小值,为当前趟数对应下标值，然后依次和其他未元素进行比较，如果发现存在更小的元素，记录下这个最小值的下标。
* 一趟结束后观察 min 下标有无变化，有变化则交换 无则不管。
* */
public static void choose(int[] data ){
for(int i=0;i<data.length;i++){ // 控制趟数。
//假设当前趟数出的元素就是最小的
int min = i;
//用假设的这个元素 依次和后续元素比较。
for(int j=i+1; j<data.length;j++){
if( data[min] > data[j] ){
min = j; //如果有更小的记录下标
}
}
//观察是否有变化
if(min !=i){
//交换
int temp = data[min];
data[min] = data[i];
data[i] =temp;
}
}
}
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕
Arrays.sort( T[] arr )
java.util包下带的方法
public static void main(String[] args) {
int [] arr = {49,38,65,97,76,13,27,49};
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
原文：https://www.cnblogs.com/ShangStudyJava/p/14719663.html