类{
    方法{
        语句;
    }
}

public class HelloWorld {
  	public static void main(String[] args) {
    	System.out.println("HelloWorld");
  	}
}

\n：换行
\r：回车
\t：Tab键
\\：\
\"："
\'：'
\b：删除键Backspace

char c2 = 97;
System.out.println(c2);//a

//查看某个字符的Unicode编码
int codeOfA = 'A';
System.out.println(codeOfA);
int codeOfTab = '\t';
System.out.println(codeOfTab);

char c = '\u0041'; //十进制Unicode值65，对应十六进制是41，但是\u后面必须写4位
char c = '\u5c1a'; //十进制Unicode值23578，对应十六进制是5c1a

数据类型  变量名;
例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

int age = 18;
double weight = 84.4;
char gender = '男';
boolean marry = true;
String name = "佟刚";

char c = '尚';//使用单引号
String s = '尚';//错误的，哪怕是一个字符，也要使用双引号
		
char kongChar = '';//错误，单引号中必须有且只能有一个字符
String kongStr = "";//可以，双引号中可以没有其他字符，表示是空字符串

//输出变量的值
System.out.println(age);

//输出变量的值
System.out.println("name" + name + ",age = " + age + "，gender = " + gender + ",weight = " + weight + ",marry = " + marry);

public class ConstantDemo {
	public static void main(String[] args) {		
		//输出整数常量值
		System.out.println(12);
		System.out.println(-23);
        System.out.println(2352654566L);
		
		//输出小数常量值
        System.out.println(12.34F);
		System.out.println(12.34);
		
		//输出字符常量值
		System.out.println('a');
		System.out.println('0');
		
		//输出布尔常量值
		System.out.println(true);
		System.out.println(false);
        
        //输出字符串常量值
		System.out.println("HelloWorld");
	}
}

public class FinalVariableDemo {
	public static void main(String[] args){
        //定义常量
        final int FULL_MARK = 100;//满分
       // FULL_MARK = 150;//错误，final修饰的变量，是常量，不能重新赋值
        
        //输出常量值
        System.out.println("满分：" + FULL_MARK);
        
        //小王的成绩比满分少1分
        int wang = FULL_MARK - 1;
        //小尚得了满分
        int shang = FULL_MARK;
        //小刘得了一半分
        int liu = FULL_MARK/2;
        
        //输出变量值
        System.out.println("小王成绩：" + wang);
        System.out.println("小尚成绩：" + shang);
        System.out.println("小刘成绩：" + liu);
	}

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double

byte b = 127; //右边的整数常量值必须在-128~127范围内
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，否则编译不通过

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
System.out.println(c1 + c2);//113 

数据类型 变量名 = （数据类型）被强转数据值;  //()中的数据类型必须<=变量的数据类型，一般都是=

int i = (int)3.14;//强制类型转换，损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

int i = 1;
int j = 2;
double shang = (double)i/j;

System.out.println("" + 1 + 2);//12

String str = "123";
int num = (int)str;//错误
int num = Integer.parseInt(str);//该方法可以把str转换为int

String str1 = 4;        				//报错
String str2 = 3.5f + "";             	//
System.out.println(str2);        		//输出：3.5
System.out.println(3+4+"Hello!");      	//输出：7Hello
System.out.println("Hello!"+3+4);      	//输出：Hello!34
System.out.println('a'+1+"Hello!");    	//输出：98Hello!
System.out.println("Hello"+'a'+1);      //输出：Helloa1

int a = 10;
a++; // 后加加

a = 10;
++a; // 前加加

int x = 20;
int y = ++x; // 先加后用, x : 21, y : 21

x = 20;
y = x++; // 先用后加, x : 21, y : 20 先把a中的老值放入临时空间t，再把a++=21，然后把临时空间t的值赋值给b。

a = 10;
a = a++;//此时a的打印是10，原理见上。***

10++;//错误，10是常量，++只能针对变量。

//for循环的优化-优化前
for(int i = 0;i < arr.length;i++){
    
}
//for循环的优化-优化后
for(int i = 0;i != arr.length;++i){//++i不需要临时内存，'!='的效率优于'-'
    
}

boolean b1 = 1 <= a < 10;//错误，自左向右依次判断， 1<=a判断完成后，转为true即boolean类型，而boolean型不能参与比较大小运算。
boolean b1 = 1 <= a && a < 10;//正确
boolean b1 = 1 <= a == true;//正确

条件表达式？表达式1：表达式2

//找到两者的最大值
public static void main(String[] args){
	int n1 = ?;
	int n2 = ?;
    int max = n1 > n2 ? n1 : n2;
}

public static void main(String[] args){
	int a;
	a = 10;
	System.out.println(a);//打印的是a中的副本
	System.out.println(a = 10);//打印表达式本身
	//赋值表达式的结果值就是它的最右值。
	
	int n1,n2,n3,n4;
	n1 = n2 = n3 = n4 = 100;//从右向左赋值，n3被赋予的是'n4 = 100'的表达式本身的值。
}

if (条件表达式)｛
  	语句体;
｝

if(关系表达式) { 
  	语句体1;
}else {
  	语句体2;
}

public class TestIfElse {
    public static void main(String[] args){
        int inputNum = Integer.parseInt(args[0]);

        if(inputNum % 7 == 0) {
            System.out.println(inputNum + "可以被7整除");
        } else{
            System.out.println(inputNum + "不可以被7整除");
        }

    }
}

if(){
	if(){	
	
	}else{
	
	}
}else{

}

//如果case中没有break，会形成fall through.穿透
//如果某个case一旦进入，后面的所有case形同虚设，直到遇到break中switch结束。
switch(表达式){//必须是非long整数的变量/字符串/枚举
    case 常量值1: // if (表达式==常量值1)，必须是常量，因为它的底层是一个表格。
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】   
    。。。
   【default:  // else
        语句块n+1;
        【break;】
     】
}

import java.util.Scanner;

/*
 * 需求：指定一个月份，输出该月份对应的季节。
 * 		一年有四季
 * 		3,4,5	春季
 * 		6,7,8	夏季
 * 		9,10,11	秋季
 * 		12,1,2	冬季
 */
public class Test14SwitchDemo2 {
    public static void main(String[] args) {
        int month = Integer.parseInt(args[0])

        /*
		switch(month) {
            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;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            default:
                System.out.println("你输入的月份有误");
                break;
		}
		*/

        // 改进版
        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
                break;
        }
    }
}

[初始化语句;]
while (循环条件语句) {
    循环体语句；
    [迭代语句;]
}

while(1 == 1) //报错，不可能到达。死循环
    
boolean flag = true;
while(flag) //不会报错，因为flag是变量，java认为有可能退出循环。称为无限循环。无限循环的存在是好的，相当于程序可以一直运行。

[初始化语句;]
do {
    循环体语句；
    [迭代语句;]
} while (循环条件语句)；

for (初始化语句A; 循环条件语句B; 迭代语句C) { /
	循环体语句D; 
}

while (true) {
    语句块;
}

do {
    语句块;
} while (true);

for(;;){
    循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}

//增强for循环,利用tmp让修改内容的位置在栈中而不是直接修改堆中的内容,更安全适用于只读访问.
for(int tmp : arr){
	System.out.println(tmp + " ");
}

//经典for循环,适用于写入操作或和下标密切相关的操作
for(int i = 0;i< arr.length;++i){
    
}

for(初始化语句A; 循环条件语句B; 迭代语句C) {//外循环控制行
    for(初始化语句D; 循环条件语句E; 迭代语句F) {//内循环控制列
      	循环体语句G;
    }
    循环体语句H;
}

for (int i = 0; i < 10; i++) {
    if (i == 3) {
        break;
    }

l1: for(int i = 0;i<5;i++){
	l2:	for(int j = 0;j<3;j++){
			System.out.println("j:" + j)
			if(j == 1){
				break l1;//中断标签指示的循环
			}
	}
}

boolean flag = true;
l3: {
    System.out.println("这是l3的语句");
    if(flag == true){//如果不在这里添加flag == true的判断而直接写break l3 后面的输出语句会报错。
        break l3;
    }
    System.out.println("这是break后的语句，如果显示那么就是出错了");
}

for (int i = 0; i < 100; i++){
    if (i % 10 == 0) {
        continue;
    }
    System.out.println("i : " + i);
}

while(true){};//死循环
while(true);//死循环

boolean flag = true;
while(flag);//无限循环，flag是变量

do{} while(true);//死循环
do{} while(flag);//无限循环

for(;;);//死循环
for(int i = 0; ; i++);//死循环
for(int i = 0;true;i++);//死循环

for(int i = 0;flag;i++);//无限循环
for(int i = 0;i<10;);//无限循环
for(int i = 0;i<10;i--);//有限循环

类{
    方法1(){
        
    }
    方法2(){
        
    }
}

【修饰符】 返回值类型 方法名(数据类型1 形参1, 数据类型2 形参2 ....){
        语句1;
    	语句2;
    	return 返回值;
}

class OverLoad_2 {

    //打印一个n*m的矩形
    public static void method1(int n, int m) {
        System.out.println("打印" + n + "*" + m + "的矩形");
        System.out.println("----------------");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        System.out.println("----------------");
    }

    //打印一个边长为n的正方形并返回周长
    public static int method1(int n) {
        method1(n, n);//连环调用，能连环调用绝不单独写，便于维护。
        return n * 4;
    }


    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);

        method1(n, m);
        method1(n);
    }
}

public class JavaBeanTest {
    public static void main(String[] args) {
        int n = 100;
        int m = 20;

        System.out.println(Another.add(n,m));//使用Another类中的add方法。
    }
}

class Another {
    public static int add(int a, int b) {
        return a + b;
    }
}

public class FibonacciTest {
    
    public static void main(String[] args) {
        System.out.println(f(10));//6765
    }

    //使用递归
    public static int f(int n){//计算斐波那契数列第n个值是多少
        if(n<1){//负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if(n==1 || n==2){
            return 1;
        }
        return f(n-2) + f(n-1);
    }
}

//推荐
元素的数据类型[] 数组的名称;

//不推荐
元素的数据类型  二维数组名[];

数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中，不能分开两个语句写

int[] arr = {1,2,3,4,5};//正确

int[] arr;
arr = {1,2,3,4,5};//错误

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};

int[] arr = new int[]{1,2,3,4,5};//正确

int[] arr;
arr = new int[]{1,2,3,4,5};//正确

public class Test03ArrayUse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        System.out.println("arr数组的长度：" + arr.length);
        System.out.println("arr数组的第1个元素：" + arr[0]);//下标从0开始
        System.out.println("arr数组的第2个元素：" + arr[1]);
        System.out.println("arr数组的第3个元素：" + arr[2]);
        System.out.println("arr数组的第4个元素：" + arr[3]);
        System.out.println("arr数组的第5个元素：" + arr[4]);

        //修改第1个元素的值
        //此处arr[0]相当于一个int类型的变量
        arr[0] = 100;
        System.out.println("arr数组的第1个元素：" + arr[0]);
    }
}

public class Test04ArrayIndexOutOfBoundsException {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
       // System.out.println("最后一个元素：" + arr[3]);//错误，下标越界ArrayIndexOutOfBoundsException
      //  System.out.println("最后一个元素：" + arr[arr.length]);//错误，下标越界ArrayIndexOutOfBoundsException
        System.out.println("最后一个元素：" + arr[arr.length-1]);//对
    }
}

for(int i=0; i<arr.length; i++){
	System.out.println(arr[i]);
}

//第一种
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];

//第二种
数组存储的元素的数据类型[] 数组名字;
数组名字 = new 数组存储的元素的数据类型[长度];

int[] arr = new int[5];

int[] arr;//在栈中开辟一个引用变量的空间，用于保存一个数组对象，此时并没有地址。
arr = new int[5];//new操作会在堆内存中创建一个真实的数组对象。占用20字节，并且所有数据都是0。

int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[]中指定元素个数了。

public class ArrayInitTest {
    public static void main(String[] args) {
        int[] arr = new int[5];

        System.out.println("arr数组的长度：" + arr.length);
        System.out.print("存储数据到arr数组之前：[");
        for (int i = 0; i < arr.length; i++) {
            if(i==0){
                System.out.print(arr[i]);
            }else{
                System.out.print("," + arr[i]);
            }
        }
        System.out.println("]");

        //初始化
 /*       arr[0] = 2;
        arr[1] = 4;
        arr[2] = 6;
        arr[3] = 8;
        arr[4] = 10;*/

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (i+1) * 2;
        }

        System.out.print("存储数据到arr数组之后：[");
        for (int i = 0; i < arr.length; i++) {
            if(i==0){
                System.out.print(arr[i]);
            }else{
                System.out.print("," + arr[i]);
            }
        }
        System.out.println("]");
    }
}

public static void main(String[] args){
	int[] arr = new int[3];
	System.out.println(arr);//[I@5f150435
}

public static void main(String[] args) {
    // 定义数组，存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2，将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
}

public class ArrayFindMaxTest{
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int max = array[0];
        int maxIndex = 0;
        for(int i = 1;i<array.length;i++){
            if(array[i] > max){
                max = array[i];
                index = i;
            }
        }
        System.out.println("最大值为：" + max);
        System.out.println("最大值的下标是：" + maxIndex);
    }
}

class ArrayFindMaxTest2{
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int maxIndex = 0;
        for(int i = 1;i< array.length;i++){
            if(array[i] > array[maxIndex]){
                maxIndex = i;
            }
        }
        System.out.println("最大值为：" + array[maxIndex]);
        System.out.println("最大值的下标是：" + maxIndex);
    }
}

import java.util.Scanner;

public class ArrayOrderSearch {
    public static void main(String[] args) {
        //找到查找到的第一个数字的位置.
        int[] array = {1, 2, 3, 4, 5, 5, 6, 7, 5};
        
        //输入要查找的数字
        Scanner input = new Scanner(System.in);
        System.out.println("请输入您要查找的数字：");
        int searchNum = input.nextInt();
        
        //查找
        for (int i = 0; i < array.length; ++i) {
            if (array[i] == searchNum) {
                System.out.println("数字的下标是: " + i);
                break;
            }
        }
    }
}

import java.util.Scanner;

public class BinarySearch {
    public static void main(String[] args) {
        /*
        二分查找的前提是数组是整体有序的。数组默认是递增的。
        首先选择数组中间的数字和目标数字对比。
          如果相等则直接返回答案。
          如果不相等-中间的数字大于目标值，则中间向右的均大于目标值，全部排除,right = mid - 1。
                  -中间的数字小于目标值，则中间向左的均小于目标值，全部排除,left = mid + 1。
        进行下一次对比。
        */

        //数组要有序，默认是递增。
        int[] array = {8, 19, 21, 34, 39, 40};

        //输入要查找的整数。
        Scanner input = new Scanner(System.in);
        System.out.println("请输入您要查找的值: ");
        int target = input.nextInt();

        //二分查找
        int index = -1;//默认-1，找不到就输出-1.
        for (int left = 0, right = array.length - 1; left <= right; ) {
            int mid = left + (right - left) / 2;

            if (array[mid] == target) {
                index = mid;
                break;
            } else if (target > array[mid]) {
                left = mid + 1;//目标大于中间值，说明目标左侧值都比目标小，left移动到mid+1位置。
            } else if (target < array[mid]) {
                right = mid - 1;//目标小于中间值，说明目标右侧值都比目标大，right移动到mid-1位置。
            }
        }

        if(index!=-1){
            System.out.println("找到了，目标位置是" + index);
        }else {
            System.out.println("没有找到。");
        }
    }
}

import java.util.Scanner;

public class BinarySearch {
    public static void main(String[] args) {
        /*
        二分查找的前提是数组是整体有序的。数组默认是递增的。
        首先选择数组中间的数字和目标数字对比。
          如果相等则直接返回答案。
          如果不相等-中间的数字大于目标值，则中间向右的均大于目标值，全部排除,right = mid - 1。
                  -中间的数字小于目标值，则中间向左的均小于目标值，全部排除,left = mid + 1。
        进行下一次对比。
        */

        //数组要有序，默认是递增。
        int[] array = {8, 19, 21, 34, 39, 40};

        //输入要查找的整数。
        Scanner input = new Scanner(System.in);
        System.out.println("请输入您要查找的值: ");
        int target = input.nextInt();

        //二分查找
        int index = -1;//默认-1，找不到就输出-1.
        for (int left = 0, right = array.length - 1; left <= right; ) {
            int mid = left + (right - left) / 2;

            if (array[mid] == target) {
                index = mid;
                break;
            } else if (target > array[mid]) {
                left = mid + 1;//目标大于中间值，说明目标左侧值都比目标小，left移动到mid+1位置。
            } else if (target < array[mid]) {
                right = mid - 1;//目标小于中间值，说明目标右侧值都比目标大，right移动到mid-1位置。
            }
        }

        if (index != -1) {
            System.out.println("找到了，目标位置是" + index);
        } else {
            System.out.println("没有找到。");
        }
    }
}

class BinarySearch_2 {
    public static void main(String[] args) {
        /*
        如果数组中有重复元素，需要考虑重复元素时，二分查找应该怎么做。
         */

        //数组必须有序。
        int[] array = {1, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10};

        //输入需要查找的数
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要查找的数：");
        int searchNum = input.nextInt();

        //二分查找
        int index = -1;//如果查找不到，返回-1.
        for (int left = 0, right = array.length - 1; left <= right; ) {
            int mid = left + (right - left) / 2;
            System.out.println("mid = " + mid);

            if (array[mid] == searchNum) {
                index = mid;
                System.out.print(searchNum + "的下标有:" + index);

                //使用二分查找的数是"有序"，如果有重复元素，那么他们是在一起的。
                //继续比较mid左边和右边的元素，直到元素与target不相等为止。

                for (int i = mid - 1; i >= left; i--) {
                    if (array[i] == searchNum) {
                        System.out.print("," + i);
                    } else {
                        break;
                    }
                }
                for (int j = mid + 1; j <= right; j++) {
                    if (array[j] == searchNum) {
                        System.out.print("," + j);
                    } else {
                        break;
                    }
                }
                System.out.println();
                break;
            } else if (searchNum > array[mid]) {
                //说明target在mid右边
                left = mid + 1;

                //如果array右边的元素和array[mid]一样，可以把左边界向右侧移动。
                while (array[mid] == array[left]) {
                    System.out.println("left = " + left);
                    left++;
                }
            } else {
                //说明target在mid左边
                right = mid - 1;

                //如果array左边的元素和array[mid]一样，可以把右边界向左侧移动。
                while (array[mid] == array[right]) {
                    System.out.println("right = " + right);
                    right--;
                }
            }
        }
        if (index == -1) {
            System.out.println("未找到目标元素。");
        }
    }
}

//数组对称位置的元素互换
public class ArrayReverse {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};//设置数组

        //循环遍历打印反转前数组
        System.out.print("反转前：");
        System.out.print(array[0]);
        for (int i = 1; i < array.length; i++) {
            System.out.print("," + array[i]);
        }
        System.out.println();

        //反转数组
        for (int i = 0; i < array.length / 2; i++) {
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }

        //循环遍历打印反转后数组
        System.out.print("反转后：");
        System.out.print(array[0]);
        for (int i = 1; i < array.length; i++) {
            System.out.print("," + array[i]);
        }


    }
}

//直接选择排序
//思想：每一轮找出本轮的最大值/最小值，然后看他是否在正确的位置，如果不在就与正确的位置交换。
    public static void selectSort(int[] arr) {
        //每次找到最小值放入到i的位置,然后i++,在下一个位置放入最小值.
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;//记录最小值的下标
            for (int j = i; j < arr.length; j++) {
                if(arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            int tmp = arr[i];//交换最小值和i位置的元素
            arr[i] = arr[minIndex];
            arr[minIndex] = tmp;
        }
    }

//冒泡排序 BubbleSort

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {1, 4, 2, 3, 6, 7, 8, 9, 4, 5, 6};

        //从左到右依次比较，将最大值移动到待比较队列最右。
        for (int i = array.length - 1; i > 0; i--) {//用i控制待排序队列的最右侧位置
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {//相邻之间如果左侧大于右侧，则把左侧值交换到右侧。
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

        //输出
        System.out.print(array[0]);
        for (int i = 1; i < array.length; i++) {
            System.out.print("," + array[i]);
        }
        System.out.println();
    }
}

//多加一个flag来控制比较次数，如果某一次排序过程中，整个数组顺序都无变动，说明已经是有序状态。

//冒泡排序 BubbleSort

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {1, 4, 2, 3, 6, 7, 8, 9, 4, 5, 6};

        //从左到右依次比较，将最大值移动到待比较队列最右。
        for (int i = array.length - 1; i > 0; i--) {//用i控制待排序队列的最右侧位置
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {//相邻之间如果左侧大于右侧，则把左侧值交换到右侧。
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

        //输出
        System.out.print(array[0]);
        for (int i = 1; i < array.length; i++) {
            System.out.print("," + array[i]);
        }
        System.out.println();
    }
}

class BubbleSort2 {
    public static void main(String[] args) {
        int[] array = {1, 4, 2, 3, 6, 7, 8, 9, 4, 5, 6};

        for (int i = array.length - 1; i > 0; i--) {
            boolean flag = true;
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = false;
                }
            }

            if(flag){
                break;
            }
        }

        //输出排序后数组
        System.out.print(array[0]);
        for (int i = 1; i < array.length; i++) {
            System.out.print("," + array[i]);
        }
        System.out.println();
    }
}

public static void QuickSort(int left, int right, int... arr) {

    //判定递归结束条件,right == left
    if (right <= left) {
        return;
    }

    //需要定义pivot,first,last.为了方便起见,pivot直接就定义成first位置的元素
    int first = left;//数组最左侧元素下标
    int last = right;//数组最右侧元素下标
    int pivot = arr[left];//pivot默认为下标为left的元素,在一趟快速排序后,应当实现的效果是:pivot左侧都比pivot位置元素小,pivot右侧都比pivot位置元素大.

    //left < right的情况下就一直进行循环,直到left == right
    while (first < last) {
        //从right指针开始,将right位置与基准值进行比较
        while (first < last && pivot <= arr[last]) {//如果left < right 且 right位置的元素比基准值大 那就right--,继续向左探寻
            last--;
        }
        arr[first] = arr[last];//如果left < right 且 right位置的元素比基准值小 那就把right指针的值放入left指针位置

        //right探测完毕后,将left位置与基准值进行比较
        while (first < last && pivot >= arr[first]) {//如果left < right 且 left位置的元素比基准值小,那就left++,继续向右探寻
            first++;
        }
        arr[last] = arr[first];//如果left < right 且 left位置的元素比基准值大,那就把left指针的元素放入到right指针元素.
    }

    arr[first] = pivot;

    //分别递归左右子数列,直到数列中只剩下一个元素
    QuickSort(left, last - 1, arr);
    QuickSort(first + 1, right, arr);
}

class Rectangle {
    double height;
    double width;

    double area() {//面积
        return height * width;
    }

    double perimeter() {//周长
        return 2 * (height + width);
    }

    String getInfo() {
        return "长：" + height +
                "，宽：" + width +
                "，面积：" + area() +
                "，周长：" + perimeter();
    }
}

public class ObjectArrayTest {
    public static void main(String[] args) {
        //声明并创建一个长度为3的矩形对象数组
        Rectangle[] rect = new Rectangle[3];

        //创建3个矩形对象，并为3个对象的实例变量赋值
        //3个矩形对象的长分别是10，20，30
        //3个矩形对象的宽分别是5，15，25
        //调用矩形对象的getInfo()返回对象信息后输出
        for (int i = 0; i < rect.length; i++) {
            //创建矩形对象
            rect[i] = new Rectangle();

            //为矩形对象的成员变量赋值
            rect[i].height = (i + 1) * 10;
            rect[i].width = (2 * i + 1) * 5;

            //获取并输出对象的信息
            System.out.println(rect[i].getInfo());
        }
    }
}

int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一维数组

//推荐
元素的数据类型[][] 二维数组名;

//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

public class ArrayDefine {
    public static void main(String[] args) {
        //存储多组成绩
        int[][] grades;

        //存储多组姓名
        String[][] names;
    }
}

int[] x,y[];//x是一维数组，y是二维数组f

//以下格式要求声明与静态初始化必须一起完成。

//静态初始化1
元素数据类型[][] 二维数组的名称 = {
    {元素1，元素2，元素3...},
    {第二行的值列表	 ...},
    ...
    {第n行的值列表 	  ...}
};

//静态初始化2
元素的数据类型[][] 二维数组名 = new 元素数据类型[][]{
    {元素1，元素2，元素3...},
    {					},
    {					}
};

//静态初始化3
元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
    {元素1，元素2，元素3...},
    {第二行的值列表	 ...},
    {					 }
};

//用二维数组存储3个组的每个学员的成绩
public class TwoDimensionalArrayUse {
    public static void main(String[] args) {

        //声明并初始化二维数组array
        int[][] score = {
                {80,60,90,50,40},
                {90,65,95,35,45},
                {20,30,40,50}
        };

        //输出行数
        System.out.println("一共有" + score.length+1 + "组");//输出行数

        //输出每个组有多少个成员，即每行有多少列
        for(int i = 0;i<score.length;i++){
            System.out.println("第" + i + "组一共有" + score[i].length + "个学员");
        }

        //输出每个组的成员的成绩，即每行每列的元素。
        for(int i = 0;i<score.length;i++){
            System.out.print("第一组的成绩是：");
            for (int j = 0;j<score[i].length-1;j++){
                System.out.print(score[i][j] + ",");
            }
            System.out.print(score[i][score.length-1]);
            System.out.println();
        }

    }
}