Java语言基础

1
2
3
4
5
6
7

public class HelloWorld{  //JAVA系统的类，文件名必须和类名相同
public static void main(String[]args){   //定义main方法(函数)，
//一个 java 程序运行必须而且有且仅有一个 main 方法。
//JAVA程序开始,String(str)表明数据类型,args表示数组
		System.out.println("hello,world"); //显示HelloWorld
	}  //注意：方法必须用大括号括起来
}

1

C: Users 35367 Desktop'TT>javac Hello.java

1
2
3
4
5
6

public class Text {   
piblic static void main (String[]args){
      System.out.println("Hello");

	}
}

1

public class Text{ //这是单行注释

1
2
3
4
5
6

public class Text{
    public static viod main (String[]args){/*这是多行注释
这是多行注释*/
        System.out.println("hello,world");
   }
}

1
2
3
4
5
6
7
8
9

/**
这是文档注释
这是文档注释
*/
public class HelloWorld{  
public static void main(String[]args){  
		System.out.println("hello,world"); 
	} 
}

1
2
3
4
5

//整型
int a = 1 ; 
byte b = 2 ; // 最大表示到127
short c = 3 ;
long d = 4 ;

1
2
3
4
5

//浮点型
double e = 0.1; //双精度浮点型
float f = 0.2f ; //单精度浮点型

double e1 = 0.1d;

1
2
3

//字符型
char c1 = 'R';
char c2 = 'T';

1

String A = "String" //字符串,记得用双引号引起来

1
2

boolean b1 = true ;
boolean b2 = false ;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//整型
int a = 1 ;
byte b = 2 ;
short c = 3 ;
long d = 4 ;


//浮点型
double e = 0.1;
float f = 0.2f ;
//在JAVA中，如果定义float类型，需要后面加个f，否则会默认转化为double类型

//字符型
char g = 'G';


//布尔型
boolean h = true;

//字符串
String i = "Hedio_Kojima" 

1
2
3

int i1 = 012 ; //八进制常量，以0开始
int i2 = 0x12 ; //十六进制常量，以0x开始
int i3 = 10 ; // 十进制常量，以0开始

1
2

//数据类型 变量名 = 初值
int a = 234

1
2
3
4
5
6

public class LBL {
    static int p=100;  //类变量
    public static void main(String[] args) {
    System.out.println(p);
    }
}

1
2
3
4
5
6

public class LBL {  
     String p="hello world";  // 实例变量    
     public static void main(String[] args) {
    System.out.println(p);
    }
}

1
2
3
4
5
6

public class LBL {      
    public static void main(String[] args) {
    int p = 123 ;
    System.out.println(p);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Text{
    static int p1=0;    // 类变量

    String p2="hello world";  // 实例变量
 
   public void method(){

        int p3 =0;  // 局部变量

    }
}

1
2
3
4
5
6
7

public static void main(String[] args) {  
    int x = 5 ;  
    int y = 10 ;  
    int z ;  
    z = y > x ? y : x ;  // y > x 为true, 返回10  
    System.out.println(z);  
}

1

10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Demo {  
    public static void main(String[] args) {  
        int x = 5;  
        int y = 10;  
        int z;  
        z = ++x + y++;  
        System.out.println(z);  
    }  
}  
// 1+5+10,运算完成后，y+1

1

16

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Expression {
  public static void main(String[] args) {
      int a = 10, b = 20;
      // (a + b) * 2 就是一个算数表达式
      int c = (a + b) * 2;
      // c > b 就是一个布尔表达式
      if (c > b) { 
          System.out.println("c大于b");
        }
    }
}

1
2
3
4
5
6
7
8
9

public class Demo {  //创建demo类
    public static void main(String[] args){  //main方法
        System.out.println("1");  //顺序结构将从上往下依次进行
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/**
if (logic expression){
statments
}
*/


public class Demo {
    public static void main(String[] args){
        int a = 10 ;
        if (a > 1)  {  //单选择if
            System.out.println("a > 1 ") ;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
if (logic expression){  // logic expression为布尔类型
statments
}
else{
statments
}
*/


public static void main(String[] args) {  
    int a = 10 ;  
    int b = 5 ;  
    boolean c = true ;  
    boolean d = false ;  
  
    if (a < b) {  //if 语句分支  
        System.out.print(c);  
    }  
    else { // else 语句分支  
        System.out.println(d);  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
if (logic expression){  // logic expression为布尔类型
statments
}

else if (logic expression){
statments
}
else{
statments
}
*/
public static void main(String[] args) {  
    int a = 10;  
    int b = 5;  
    int c = 10;  
    boolean d = true;  
    boolean e = false;  
  
    if (a == b) {  // if分支  
        System.out.print(d);  
    } else if (a == c) { // else if 分支  
        System.out.println("a == 10");  
    } else {  // else 分支  
        System.out.println(e);  
    }  
  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
if (logic expression){
    if (logic expression){
        statments
        }
    }
*/





public class Demo {
    public static void main(String[] args){
        int a = 9 ;
        if (a == 9){ // if语句A
            if (a != 10){  // if语句B`
                System.out.println("Ture");
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
switch (expression){
    case value1 :
    statments
    break;//用于控制单个选项输出,否则就会输出剩下的语句

    case value2 :
    statments
    break;

   default:{  //前面case都没有执行的话运行
   statments
}
*/




public class Demo {
    public static void main(String[] args) {

        int a = 9 ;


        switch (a){  //switch语句

            case 8 :  //case a
                System.out.println("a = 8");
                break;//用于控制单个选项输出

            case 9 :  //case b
                System.out.println("a = 9");
                break;

            default :{
                System.out.println("a = default");
            } 

        }


    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
while (条件) {

//语句

}
*/





public class Demo {
    public static void main(String[] args) {
        int a = 0 ;

         while (a < 10) {  //while循环，判断变量a 小于零，执行循环
             a++;
             System.out.println(a);
         }

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Demo1 {
    public static void main(String[] args) {


        int x = 0 ;
        int x1 = 0 ;
        int y1 = 0 ;

        while (x<100){
            if (x % 2 == 0) { //偶数
                x1 = x1 + x ;
            }
            else {
                y1 = y1 + x ; //奇数
            }
            x++ ;
        }
        System.out.println("偶数和" + x1);
        System.out.println("奇数和" + y1);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 do{
 //代码
 }while(不布尔表达式);
 */



public class Demo {
    public static void main(String[] args) {
        int a = 0 ;
        int b = 0 ;

        do{
            ++a ;  //是do - while语句，a将输出10
        }while (a<10);
        System.out.println(a);


        while(a<0); //while语句，直接跳出循环，b为0
        }
        System.out.println(b);

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Demo1 {
    public static void main(String[] args) {
        int x = 0;
        int x1 = 0;
        int y1 = 0;

        do {
            if (x % 2 == 0) {
                x1 = x1 + x;
            }
            else {
                y1 = y1 + x;
            }

            x++;
        }while (x < 100) ; //)~100

            System.out.println("偶数和" + x1);
            System.out.println("奇数和" + y1);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/**
for (初始化，布尔表达式,迭代){
//代码语句
}
*/




public class Demo {
    public static void main(String[] args) {
        for ( int a = 0 ; a<10 ; a++){  //for (初始化,布尔表达式,迭代)
            System.out.println(a);  //输出a
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Demo1 {
    public static void main(String[] args) {
    
    for(int a=0,b=0,c=0;a<10 && b<10 && c<10;a++,b++,c++) {
    System.out.println(a) ;
    System.out.println(b) ;
    System.out.println(c) ;
    }
    
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Demo1 {
    public static void main(String[] args) {

        int x1 = 0 ;
        int y1 = 0 ;


        for (int x = 0;x < 100; x++){
            if (x % 2 == 0){
                x1 = x1 + x ;
            }
        }

        for (int y = 0 ;y < 100 ;y++){
            if (y % 2 == 1){
                y1 = y1 + y ;
            }
        }
        System.out.println("偶数和" + x1);
        System.out.println("奇数和" + y1);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class TTT {
        public static void main(String[] args) {
            for (int a = 1;a < 10;a++){
                for (int b = 1; b <= a;b++){
                    System.out.print(b + "X" + a + "=" + a*b + "\t");
                }
                System.out.println();
            }
        }
}

1
2
3
4
5
6
7
8

public class Demo1 {
    public static void main(String[] args) {
        int [] num = {1,2,3,4,5,6,7,8,9,0} ;  //定义数组
        for ( int x : num ){  //for (声明语句:表达式)
            System.out.println(x);
        }
    }
}

1
2
3
4
5
6
7
8

public static void main(String[] args) {  
    for (int x = 0; x <= 100; x++) {  
        System.out.println(x);  
        if (x == 10) {  
            break;  
        }  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

0
1
2
3
4
5
6
7
8
9
10

进程已结束,退出代码0

1
2
3
4
5
6
7
8
9

public static void main(String[] args) {  
    for (int x = 0; x <= 11; x++) {  
        if (x % 10 == 0) {  
            System.out.println("ZZZ");//x被10整除的时候输出,并且跳出if。进入循环  
            continue;  
        }  
        System.out.println(x);  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

ZZZ
1
2
3
4
5
6
7
8
9
ZZZ
11

1

import java.util.Scanner ; //引用Scanner类库

1

Scanner s = new Scanner(System.in);  //Scanner 基本语法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.util.Scanner ; //引用Scanner类库


public class Demo1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //创建Scanner来检测用户输入

        System.out.println("请输入");
        if (scan.hasNext()){  //scan.hasNext（）判断是否输入

            String input =  scan.next() ;  //用scan.next()来获取输入的内容

            System.out.println("输入的是" + input);  //输出
        }
        //Scanner属于IO流，不用的时候应该关掉,否则会一直占用资源
        scan.close(); //停止运行
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.util.Scanner ; //引用Scanner类库


public class Demo1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //创建Scanner来检测用户输入


                System.out.println("请输入");
        if (scan.hasNextLine()){  //scan,hasNextLine（）判断是否输入

            String input =  scan.nextLine() ;  //用scan.nextLine()来获取输入的内容

            System.out.println("输入的是" + input);  //输出
        }
        //Scanner属于IO流，不用的时候应该关掉,否则会一直占用资源
        scan.close(); //停止运行


    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Demo1 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //创建Scanner来检测用户输入

        //和
        double All = 0 ;

        //输入的数字数量
        int sum = 0 ;

        //输入的数字
        double a = 0 ;

        System.out.println("输入");

    while ( scan.hasNextDouble() ){

        a = scan.nextDouble() ;
        sum++ ;
        All = All + a ;
        System.out.println("已经输入了" + sum +"个数字,当前结果为" + All );
        }

        System.out.println("一共输入了" + sum +"个数字");
        System.out.println("平均值为" + All/sum);

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
*/


    public static void main(String[] args) {  //main
       int  add =  add (1,  2) ;  //给方法的参数赋值

        System.out.println(add);  //调用方法使用
    }

    public static int add (int a, int b){ 
 /*
修饰符public static
返回类型 int
方法名 add 
数据类型是 int
数据名是 a , b
*/
        int c = a + b ;
   
        return c ; //返回c 值
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    public static void main(String[] args) {
       int  add =  add (1,  2) ;

        System.out.println( "add方法: " + add);
        N(0);
    }

    public static int add (int a, int b){  //整数加法方法
        int c = a + b ;
        return c ;
    }

    public static int N (int a){  //循环输出数字方法，这里的a是形参
    for (int  b = 0 ; b <= 5 ; b++){ // 这里的b为实参
        System.out.println(b);

        a = b ; //将实参的值赋给形参
    }

    return a ;  //返回a值
    }

1

int larger = max(30, 40);

1

System.out.println("Hello,World！");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class Demo {
    public static void main(String[] args) {
       int  add =  add (1,  2) ;

        System.out.println( "add方法: " + add);
        System.out.println( "N方法: " + N(0));
        Text( 2) ;

//      Text() ;

    }

    public static int add (int a, int b){  ///add方法，返回值int
        int c = a + b ;
        return c ;
    }

    public static int N (int a){
    for (int  b = 0 ; b <= 2 ; b++){  //N方法，返回值int
        a = b ;
    }
    return a ;
    }

    public static void Text(int a ){ //Text方法,返回值void，不用加return
        if (a == 2){
            System.out.println("Text:" + a);
        }
    }

//  public static void Text(){
//          System.out.println("Text");
//  }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class Demo {
    public static void main(String[] args) {
        double a = N(1) ;
        int b = N(2) ;
        System.out.println(a);
        System.out.println(b);

    }
    //int
    public static int N (int a){  //方法N,返回值 int
    return a ;
    }


    //double
    public static double N (double c){  //方法N,返回值 double 
        return c ;
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Demo1 {
    public static void main(String[] args) {
        Demo1 Demo1 = new Demo1() ; //定义一个demo1
        Demo1.Text(1,2,3);  //调用Text方法
    }


    public static void Text (int ...i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    int b = 0 ;
    public static void main(String[] args) {
        Text(1,0) ;
    }

    public static int Text (int i ,int b ){
        if (b < 100){
            System.out.println(i);
            b ++ ;
        }
        return Text(i,b) ;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Demo {
    public static void main(String[] args) {
//            Text(0) ;
            Text(9999);
    }

    public static int Text (int b ){
        if (b <= 10){ //递归体
            System.out.println(b);
            return 10 ;
        }else {
            return Text(b-1) ;//递归头
        }

}

1
2
3
4
5
6

public class MI{
    int P = 10;  //普通变量 P
    public void BB (){
        System.out.println(P);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class iiuiu {
    public static void main(String[] args){
    MI M1 = new MI();
    M1.P = 100; //给实例 M1的变量 P 赋值
    M1.BB();

    MI M2 = new MI();
    M2.BB();
    }
}

1
2

100
10

1
2
3
4
5
6

public class MI{
    static int P = 10; //静态变量 P
    public void BB (){
        System.out.println(P);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Phone {
    public static void main(String[] args){
    MI M1 = new MI();
    M1.P = 100;
    M1.BB();

    MI M2 = new MI();
    M2.BB();
    }
}

1
2

100
100

1
2
3
4
5
6

public class House {
    static int A ; //静态变量A
    public static void DDD(){ //静态方法DDD
        A = 10;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/*
声明数组
dataType[] arrayRefVar;   // 首选的方法
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法
*/
/*
创建数组并赋值
arrayRefVar = new dataType[arraySize];
arrayRefVar [] = value ;
*/


public class Demo {
    public static void main(String[] args) {
        int[] int1 ;//声明int数组，名为int1
        int1 = new  int [10] ;//创建有10个空间数组
        int1[0] =  10 ;//给数组第一个数赋值10
        System.out.println ("int1 [0]=" + int1 [0]);//输出
    }

}

1

int1 [0]=10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Demo {
    public static void main(String[] args) {
        int[] int1 ;//声明int数组，名为int1
        int1 = new  int [10] ;//创建有10个空间数组
        for (int i = 0 ;i <int1.length;i ++){ /*定义整数i,arrays.length获取数组长度*/
            int1 [i] = i ; //将i循环赋值给数组对应的元素
            System.out.println ( int1 [i]);//输出各个元素
        }
    }

}

1
2

int [] a = {1,2,3} ;  //创建 + 赋值  (静态初始化)
Man [] mans = {new Man(1,1),new Man(2,2)} ;

1
2
3

int [] a = new int[2] ; //包含默认初始化 (动态初始化,默认值为0)
a [0] = 1 ;
a [1] = 2 ;

1
2
3
4
5
6
7
8

public class Demo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5} ;
        for (int b = 0 ;b<a.length;b++){  //遍历数组元素
            System.out.println(a[b]);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Demo {
    public static void main(String[] args) {
        int d = 0 ;

        int[] a = {1,2,3,4,5} ;
        for (int c = 0 ;c <a.length; c++){
            d = d + a[c] ;
        }
        System.out.println("所有元素和 =" + d);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Demo {
    public static void main(String[] args) {


        int[] a = {1,2,3,4,5} ;
        int Max = a[0] ;
        for (int e = 0 ; e<a.length ; e++){
            if (Max < a[e]){
                    Max = a[e] ;
            }
        }
        System.out.println("Max =" + Max);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

        for (int b : a ){  
//for - each遍历数组
            System.out.println(b);
        }

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Demo {
    public static void main(String[] args) {

        int[] a = {1,2,3,4,5};

        Text(a) ;

    }
    public static void Text (int[] a){
        for (int b = 0 ;b<a.length;b++){  //遍历数组元素
            System.out.print(a[b] + "\n");
        }
    }
    
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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


       int[] II =  TText(a) ;
       Text(II);
    }

    public static void Text (int[] a){
        for (int b = 0 ;b<a.length;b++){  //遍历数组元素
            System.out.print(a[b] + "\n");
        }
    }


    public static int[] TText (int[] a) {
        int[] G = new int[a.length] ;

        for (int Y = 0,U = a.length - 1;Y<a.length;Y++,U--){
            G[U] = a[Y] ;
        }
        return  G;
        }

}

1
2

int[] [] a = new int [2] [5] ;
int [] [] a = {{1,2,3,4,5},{6,7,8,9,0}} ;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

        for (int i = 0;i<a.length;i++){ //{1,2}{3,4}{5,6}
            for (int t =0;t<a[i].length;t++){ //1,2,3,4,5,6
                System.out.println(a[i][t]);
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {

        try {

            List list = new ArrayList();
            list.add("String");
            list.add(123);

            for ( int i = 0;i < list.size();i++){
                System.out.println((String) list.get(i));  //(String)强制转化
            }

        }catch (ClassCastException classCastException){
            System.out.println(classCastException);
        }

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();  //使用泛型
        list.add("String");
        list.add(123);

        for (int i = 0; i < list.size(); i++) {
            System.out.println((String) list.get(i));
        }
        
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    public static int[] T(int[] a){  //名为T的冒泡排序
        int Y = 0;//临时变量

        for (int Q = 0;Q<a.length-1;Q++){ //列表多少个元素，循环次数的作用
            for (int W = 0;W<a.length-1-Q;W++){ //每次循环减少，循环次数
                if (a[W]>a[W+1]){//比大小
                    Y = a[W] ; //大的值赋给临时变量
                    a[W] = a[W+1] ; //小的值前移
                    a[W+1] = Y ; //大的值赋给后面
                }
            }
        }
        return a ;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Demo1 {
    public static void main(String[] args) {
    int [] a = {1,3,4,2,5,6,9,7} ;
    Text(T(a)) ;
    }


    public static int[] T(int[] a){  //名为T的冒泡排序
        int Y = 0;//临时变量

        for (int Q = 0;Q<a.length-1;Q++){ //列表多少个元素，循环次数的作用
            for (int W = 0;W<a.length-1-Q;W++){ //每次循环减少，循环次数
                if (a[W]>a[W+1]){//比大小
                    Y = a[W] ; //大的值赋给临时变量
                    a[W] = a[W+1] ; //小的值前移
                    a[W+1] = Y ; //大的值赋给后面
                }
            }
        }
        return a ;
    }

    public static void Text (int[] a){
        for (int b = 0 ;b<a.length;b++){  //遍历数组元素显示
            System.out.print(a[b] + "\n");
        }
    }

}