一.简介


1.java可划分为三个技术平台:

(Java Platform Standard Edition)标准版,是核心部分。

企业版,是技术平台。

小型版,小型电子设备软件程序的开发。

2. 

(1)   .JDK(Java Development Kit)是JAVA的核心,包括编译器,运行工具,文档生成工具,打包工具等。‚JDK安装目录下的子目录:

bin目录:存放可执行工具,如javac .exe(编译器)、java .exe(运行工具)、jar.exe(打包工具)、javadoc.exe(文档生成工具)等。

db目录:是一个小型的数据库,学习JDBC时不需要额外安装一个数据库软件,直接使用JavaDB即可。

jre目录:java运行时环境的根目录,但不包含开发环境中的开发工具。

Include目录:存放头文件。

lib目录:java类库或库文件,是开发工具使用的归档包文件。

src.zip文件:src中存放JDK核心类的源代码,即javac.exe{编译器工具,java源文件的扩展名为.java,编译后生成的java字节码文件的扩展名为.class}和java.exe{运行工具,会启动一个Java虚拟机(JVM)进程,专门负责运行由java编译器生成的字节码文件(.class文件)}

(2)    . JRE 是java运行环境,提供给普通用户使用的,只包含运行工具,不包含编译工具。



package hello;
public class helloworld {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a=1;
		int b=2;
		int x=a+b++;
		System.out.print("b="+b);
		System.out.print(" x="+x);	
	}
}

输出:b=3 x=3 .


二.基础语法






1.标识符




 标识符不能以数字开头,不能是java中的关键字。

原则:

(1).包名所有字母一律小写。

(2).类名和接口名每个单词的首字母都要大写。

(3).常量名所有字母都大写,单词之间用下划线连接。

(4).变量名和方法名的第一个单词首字母小写,从第二个单词开始每个单词首字母大写,如lineNumber。


2.变量的数据类型

(1)基本数据类型:

数值型:整数类型(byte,short,int,long);浮点类型(float,double)

字符型 (char)

布尔型  (boolean a=false或true)

(2)引用数据类型

类(class),接口(interface),数组,枚举(enum),注解(annotation)

注意:

(1)在long类型的变量赋值时,若赋值超过int型的范围,则必须加上L或l。 例如:long num=2200000000L;

(2)在java中一个小数会被默认为double类型的值,在为float类型的变量赋值时后面一定加上字母F或f。

(3)强制类型转换:目标类型变量=(目标类型)值,但仍可能导致前面高位字节的数据丢失。





3.逻辑运算符

与:&(与),&&(短路与)。 即两边都为true时,结果才为true。

在使用&时,不论左边为true或者false,右边都会进行运算;如果是&&,当左边是false时,右边不会进行运算。

或:|(或),||(短路或)。 


4.方法

(1)什么是方法

eg1.输出矩形:

package hello;
public class Main {
	public static void main(String[] args) {
		// 调用printRectangle()方法实现打印矩形
		printRectangle(3, 5);
		printRectangle(2, 4);
		printRectangle(6, 10);
	}
	// 方法体{}
	public static void printRectangle(int height, int width) {
		for (int i = 0; i < height; i++) {
			for (int j = 0; j < width; j++)
				System.out.print("*");
			System.out.print("\n");
		}
		System.out.print("\n");
	}
}



运行结果:


*****
*****
*****


****
****


**********
**********
**********
**********
**********
**********

修饰符  返回值类型方法名([参数类型 参数名1,参数类型 参数名2,......]){

执行语句...

return返回值;

}

eg2.输出面积

package hello;
public class Main {
	public static void main(String[] args) {
		// 调用getArea方法
		int area = getArea(3, 5);
		System.out.println("The area is " + area);
	}
	public static int getArea(int x, int y) {
		int temp = x * y;
		return temp;
	}
}



输出结果:The area is 15


java 将一个数组拼接成数字join_java 将一个数组拼接成数字join


(2)方法的重载

Java允许在一个程序中定义多个名称相同的方法,但是参数的类型或个数必须不同,这就是方法的重载。


(3)方法的递归

方法的递归就是在一个方法的内部调用自身的过程,递归必须要有结束条件,否则就会陷入无限递归的状态。


package hello;

public class Main {
	public static void main(String[] args) {
		// 调用递归方法获得1-4的和
		int sum = getSum(4);
		System.out.println("sum = " + sum);
	}

	// getSum()方法用于计算1-n之间的自然数之和.
	public static int getSum(int n) {
		if (n == 1) {
			// 满足条件,递归结束
			return 1;
		}
		// 相当于在getSum()方法的内部调用了自身.
		int temp = getSum(n - 1);
		return temp + n;
	}
}



输出结果:sum = 10


java 将一个数组拼接成数字join_java_02




5.字符串





(1) 创建字符串






在java中把字符串作为对象来管理,因此像创建其他类对象一样来创建字符串对象,创建对象要用类的构造方法,String 类的常见构造方法如下:






1) String (char a[])   用一个字符数组a创建String对象   String (char[] value )



char a[]={‘g’,'o','o','d'};   String s=new String(a);



等价于  String s=new String("good");






2)   String (char a[] , int offset , int length)  提取字符数组a中的一部分创建一个字符串对象。



char a[] = {'s','t','u','d','e','n','t'};  String s=new String(a,2,4);



等价于 String s=new String ("uden");






(2)获取字符串长度



String str = "hhhhhhh";



int size = str.length();






(3) 字符串查找



String 类提供了两种查找字符串的方法:



indexOf() 方法返回的是搜索的字符或字符串首次出现的位置,lastIndexOf() 方法返回的是搜索的字符或字符串最后一次出现的位置。 如果没有检测到,则返回-1。



注意:如果str.lastIndexOf("")(没有空格) 返回结果与 str.length() 相同。






(4)获取指定索引位置的字符



str.charAt(int index)






(5)获取子字符串



1)substring(int beginIndex) 返回的是从指定的索引位置开始截取直到该字符串结尾的子串。



2)substring(int beginIndex,int endIndex) 






(6)去除空格



trim() 返回字符串的副本,忽略前导空格和尾部空格。



package hello;

public class Main {
	public static void main(String args[]) {
		String str = " abc d ";
		int s1 = str.length();
		int s2 = str.trim().length();
		System.out.println(s1 + " " + s2);
	}
}

输出结果:7 5






(7) 字符串替换



str.replace(char oldChar,char newChar);






(8)判断字符串是否以指定的内容开始或结束 



 startsWith(String prefix);  str.endsWith(String suffix) 这两个方法的返回值都为boolean类型。






(9) 判断字符串是否相等






不能简单的使用比较运算符==



1)str.equals(String otherstr)    区分大小写



如果str和otherstr 这两个字符串具有相同的字符和长度时,返回true。



2)str.equalsIgnoreCase(String otherstr)   不区分大小写。






package hello;

public class Main{ // 新建类
	public static void main(String[] args) { // 主方法
		String str = new String("We are students");
		String str2 = new String("I like Java");
		String newstr = str.substring(1,3);
		String newstr2 = str2.substring(1,3);
		if(newstr.equalsIgnoreCase(newstr2)){
			System.out.println("两个字符相同");
		}
		else{
			System.out.println("两个字符不相同");
		}
		}
}






(10)按字典顺序比较两个字符串



str.compareTo(String otherstr)   如果按字典顺序此String对象位于参数字符串之前,则比较结果是一个负整数,..之后..是正整数,如果两个字符串相等,则结果为0.





package hello;

public class Main {
	public static void main(String args[]) {
		String str1 = new String("b");
		String str2 = new String("a");
		String str3 = new String("c");
		System.out.println(str1 + " compareTo " + str2 + ":"
				+ str1.compareTo(str2));
		System.out.println(str1 + " compareTo " + str3 + ":"
				+ str1.compareTo(str3));
	}
}





输出结果:



b compareTo a:1
b compareTo c:-1






(10)字母大小写转换



str.toLowerCase();  将String转换为小写。   str.toUpperCase(); 转换为大写。






package hello;

public class Main { 
	public static void main(String[] args) { 
		String str = new String("hello WORD");
		String newstr = str.toLowerCase();
		String newstr2 = str.toUpperCase();
		System.out.println("转换为小写为:"+newstr);
		System.out.println("转换为大写为:"+newstr2);
		}
}
/*
输出结果
转换为小写为:hello word
转换为大写为:HELLO WORD
*/









(11)字符串分割



str.split(String sign);   str.split(String sign,int limit);  limit限定拆分的次数。





package hello;

public class Main {
	public static void main(String args[]) {
		String str = new String("abc,def,ghi,jkl");
		String[] newstr1 = str.split(",");
		for (int i = 0; i < newstr1.length; i++) {
			System.out.println(newstr1[i]);
		}
		System.out.println();
		String[] newstr2 = str.split(",", 3);
		for (int i = 0; i < newstr2.length; i++) {
			System.out.println(newstr2[i]);
		}
	}
}

输出结果:



abc
def
ghi
jkl


abc
def
ghi,jkl





12) 格式化字符串    format()方法
1)常规类型格式化






java 将一个数组拼接成数字join_字符串_03






2)对日期、时间字符串格式化



Date date=new Date();//创建Date对象date



String s=String.format("%te",date);






package hello;

import java.util.Date;
import java.util.Locale;

public class Main {
	public static void main(String[] args) {
		Date date = new Date();
		System.out.printf("全部日期和时间信息:%tc%n", date);
		System.out.printf("年-月-日格式:%tF%n", date);
		System.out.printf("月/日/年格式:%tD%n", date);
		System.out.printf("HH:MM:SS PM格式(12时制):%tr%n", date);
		System.out.printf("HH:MM:SS格式(24时制):%tT%n", date);
		System.out.printf("HH:MM格式(24时制):%tR%n", date);
		/*
		 * 输出结果 全部日期和时间信息:星期五 八月 25 11:50:52 GMT+08:00 2017
		 *  年-月-日格式:2017-08-25
		 * 月/日/年格式:08/25/17 
		 * HH:MM:SS PM格式(12时制):11:50:52 上午
		 * HH:MM:SS格式(24时制):11:50:52 
		 * HH:MM格式(24时制):11:50
		 */

		String str = String.format(Locale.US, "英文月份简称:%tb", date);// b,月份简称
		System.out.println(str);
		System.out.printf("本地月份简称:%tb%n", date);

		str = String.format(Locale.US, "英文月份全称:%tB", date);// B,月份全称
		System.out.println(str);
		System.out.printf("本地月份全称:%tB%n", date);

		str = String.format(Locale.US, "英文星期的简称:%ta", date);// a,星期简称
		System.out.println(str);

		System.out.printf("本地星期的简称:%tA%n", date);// A,星期全称

		str = String.format(Locale.US, "小写字母的上午或下午标记(英):%tp", date);// p
		System.out.println(str);
		System.out.printf("小写字母的上午或下午标记(中):%tp%n", date);
		/*
		 * 输出结果 英文月份简称:Aug 
		 * 本地月份简称:八月 
		 * 英文月份全称:August 
		 * 本地月份全称:八月 
		 * 英文星期的简称:Fri
		 * 本地星期的简称:星期五 
		 * 小写字母的上午或下午标记(英):am 
		 * 小写字母的上午或下午标记(中):上午
		 */

		System.out.printf("年的前两位数字(不足两位前面补0):%tC%n", date);// C,年前两位
		System.out.printf("年的后两位数字(不足两位前面补0):%ty%n", date);// y的使用,年后两位
		System.out.printf("四位年份 : %tY%n", date);// Y,四位年份
		System.out.printf("一年中的天数(年的第几天):%tj%n", date);// j,一年中的第几天
		System.out.printf("两位数字的月份(不足两位前面补0):%tm%n", date);// m,月份
		System.out.printf("两位数字的日(不足两位前面补0):%td%n", date);// d,一个月中的第几天(01~31)
		System.out.printf("月份的日(前面不补0):%te%n", date);// e,日(一位不补零)
		/*
		 * 输出结果 年的前两位数字(不足两位前面补0):20 
		 * 年的后两位数字(不足两位前面补0):17
		 * 四位年份 : 2017
		 * 一年中的天数(年的第几天):237
		 * 两位数字的月份(不足两位前面补0):08
		 * 两位数字的日(不足两位前面补0):25
		 * 月份的日(前面不补0):25
		 */
		System.out.printf("2位数字24时制的小时(不足2位前面补0):%tH%n", date);
		System.out.printf("2位数字12时制的小时(不足2位前面补0):%tI%n", date);
		System.out.printf("2位数字24时制的小时(前面不补0):%tk%n", date);
		System.out.printf("2位数字12时制的小时(前面不补0):%tl%n", date);
		System.out.printf("2位数字的分钟(不足2位前面补0):%tM%n", date);
		System.out.printf("2位数字的秒(不足2位前面补0):%tS%n", date);
		System.out.printf("3位数字的毫秒(不足3位前面补0):%tL%n", date);
		System.out.printf("9位数字的毫秒数(不足9位前面补0):%tN%n", date);
		/*
		 * 输出结果 2位数字24时制的小时(不足2位前面补0):11 
		 * 2位数字12时制的小时(不足2位前面补0):11
		 * 2位数字24时制的小时(前面不补0):11 
		 * 2位数字12时制的小时(前面不补0):11 
		 * 2位数字的分钟(不足2位前面补0):50
		 * 2位数字的秒(不足2位前面补0):52 
		 * 3位数字的毫秒(不足3位前面补0):741
		 * 9位数字的毫秒数(不足9位前面补0):741000000
		 */
		System.out.printf("相对于GMT的RFC822时区的偏移量:%tz%n", date);
		System.out.printf("时区缩写字符串:%tZ%n", date);
		System.out.printf("1998-7-20 00:00:00 到现在所经过的秒数:%ts%n", date);
		System.out.printf("1998-7-20 00:00:00 到现在所经过的毫秒数:%tQ%n", date);
		/*
		 * 输出结果 相对于GMT的RFC822时区的偏移量:+0800
		 * 时区缩写字符串:GMT+08:00 
		 * 1998-7-20 00:00:00 到现在所经过的秒数:1503633052 
		 * 1998-7-20 00:00:00 到现在所经过的毫秒数:1503633052741
		 */
	}
}



(13)正则表达式






正则表达式可以用来搜索、编辑或处理文本。



Java对正则表达式的处理集中在以下两个两个类:
java.util.regex.Matcher   模式类:用来表示一个编译过的正则表达式。
java.util.regex.Pattern   匹配类:用模式匹配一个字符串所表达的抽象结果。



在其他语言中,\\ 表示:在正则表达式中插入一个普通的反斜杠,没有特殊的意义。
在 Java 中,\\ 表示:要插入一个正则表达式的反斜线,所以其后的字符具有特殊的意义。
所以,在其他的语言中,一个反斜杠\就足以具有转义的作用,而在正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用,两个 \ 代表其他语言中的一个 \,例如表示一位数字的正则表达式是 \\d,而表示一个普通的反斜杠是 \\\\。






常见的正则表达式




规则

正则表达式语法  

一个或多个汉字

^[\u0391-\uFFE5]+$ 

邮政编码

^[1-9]\d{5}$

QQ号码

^[1-9]\d{4,10}$ 

邮箱

^[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\.){1,3}[a-zA-z\-]{1,}$ 

用户名(字母开头 + 数字/字母/下划线)

^[A-Za-z][A-Za-z1-9_-]+$

手机号码

^1[3|4|5|8][0-9]\d{8}$ 

URL

^((http|https)://)?([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$ 

18位身份证号

^(\d{6})(18|19|20)?(\d{2})([01]\d)([0123]\d)(\d{3})(\d|X|x)?$




java 将一个数组拼接成数字join_java_04



java 将一个数组拼接成数字join_System_05



java 将一个数组拼接成数字join_java 将一个数组拼接成数字join_06






实例分析:



package hello;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
	public static void main(String[] args) {
		// 匹配验证email是否正确
		String str1 = "wangxinyi_2016@163.com";
		String regex = "[a-zA-Z_]{1,}[0-9]{0,}@(([a-zA-z0-9]-*){1,}\\.){1,3}[a-zA-z\\-]{1,}";
		// 编译正则表达式
		Pattern pattern1 = Pattern.compile(regex);
		Matcher matcher1 = pattern1.matcher(str1);
		boolean f1 = matcher1.matches();// 字符串是否与正则表达式相匹配
		System.out.println(f1);
// 在字符串中查询验证字符串。
		String str2 = "wangxinyi_2016@163.com";
		String regEx = ".*xin.*";// 是否包含xin子串.
		Pattern pattern2 = Pattern.compile(regEx);
		Matcher matcher2 = pattern2.matcher(str2);
		// 查找字符串中是否有匹配正则表达式的字符/字符串
		boolean f2 = matcher2.find();
		System.out.println(f2);
	}
}






(14)字符串生成器






字符串生成器即StringBuilder类,是字符串一个重要的常用类。新创建的StringBuilder对象初始容量是16个字符,可以自行指定初始长度,也可以动态地执行添加、删除和插入等字符串的编辑操作,大大提高了频繁增加字符串的效率。





package hello;

public class Main {
	public static void main(String[] args) { 
		String str = ""; // 创建空字符串
		// 定义对字符串执行操作的起始时间
		long starTime = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作
			str = str + i; // 循环追加字符串
		}
		long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间
		long time = endTime - starTime; // 计算对字符串执行操作的时间
		System.out.println("Sting消耗时间:" + time); 
		StringBuilder builder = new StringBuilder(""); // 创建字符串生成器
		starTime = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) { // 利用for循环进行操作
			builder.append(i); // 循环追加字符
		}
		endTime = System.currentTimeMillis();
		time = endTime - starTime; // 追加操作执行的时间
		System.out.println("StringBuilder消耗时间:" + time); 
	}
}
/*
输出结果:
Sting消耗时间:159
StringBuilder消耗时间:1
*/






1) append(content)方法

该方法将参数content追加到字符串生成器中。

package hello;

public class Main { 
	public static void main(String[] args) { 
		StringBuilder ss = new StringBuilder("abc");
		for (int i = 1; i <= 5; i++) {
			ss.append(i);
		}
		System.out.println(ss.toString());
	}
}
/*
输出结果
abc12345
*/



2) insert(int offset,arg)方法

向字符串生成器中的指定位置插入数据内容

package hello;

public class Main {
	public static void main(String[] args) {
		StringBuilder bf = new StringBuilder("xyi");
		bf.insert(1, "in");
		System.out.println(bf.toString());
	}
}
/*
 * 输出结果 xinyi
 */

3)delete(int start,int end)



6.数组




(1)定义一个数组,声明的同时为数组分配内存  int[ ] arr=new int[10];

int []arr; //声明一个int[]类型的变量

arr=new int[100];//创建一个长度为100的数组

定义二维数组:

int[][]arr=new int[3][4];

 int[][]arr=new int[3][];

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



(2)每个数组的索引范围是0~length-1

(3)数组的遍历:若是循环,System.out.printlnarr[i];

eg.如何定义数组以及访问数组中的元素?

package hello;

public class Main {
	public static void main(String[] args) {
		int[] arr = new int[3];
		arr[0] = 1;
		System.out.println("arr[0]= " + arr[0]);
		System.out.println("arr[1]= " + arr[1]);
		System.out.println("arr[2]= " + arr[2]);
		System.out.println("数组的长度是:" + arr.length);
	}
}



输出结果:


arr[0]= 1
arr[1]= 0
arr[2]= 0

数组的长度是:3

(4)在定义数组时只指定数组的长度,由系统自动为元素赋初值的方式称为动态初始化,静态初始化即在定义数组的同时就为数组中的每个元素赋值。

//    类型[]数组名=new类型[]{元素,元素,元素....};

//    类型[]数组名={元素,元素....};



(5)求数组的最值

package hello;

public class Main {
	public static void main(String[] args) {
		int[] arr = { 4, 1, 6, 3, 9, 8 };
		int max = getMax(arr);
		System.out.println("max = " + max);
	}

	public static int getMax(int[] arr) {
		int max = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max)
				max = arr[i];
		}
		return max;
	}
}





(6)填充替换数组元素



fill (int []arr,int value);



fill(int []arr,int formIndex,int toIndex,int value);






package hello;

import java.util.Arrays;

public class Main { 
	public static void main(String[] args) { 
		int arr[]=new int[]{1,5,6,7,9};
		Arrays.fill(arr,1,3,8);
		for(int i=0;i<arr.length;i++){
			System.out.println("第"+i+"个元素为:"+arr[i]);
		}
	}
}
/*
 * 输出结果
          第0个元素为:1
	第1个元素为:8
	第2个元素为:8
	第3个元素为:7
	第4个元素为:9
*/





package hello;

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		String arr[] = new String[] { "ac", "bc", "dc", "yc" };
		System.out.println("替换前:");
		//另一种形式的for循环,用来处理不知道arr长度的字符串。
		for (String str : arr) {//等同于 for(i=0;i<arr.length;i++) String str=arr[i];
			System.out.print(str+"\t");//\t代表一个tab,8个字符。
		}
		Arrays.fill(arr, 2, 3, "bb");
		System.out.println("\n替换后:");
		for (String str2 : arr) {
			System.out.print(str2+"\t");
		}
	}
}
/*
替换前:
ac	bc	dc	yc	
替换后:
ac	bc	bb	yc
*/




(7).对数组进行排序





Arrays.sort(object)  //object 指数组名称






(8)数组的复制






copyOf(arr,int newlength); 复制数组至指定长度.



copyOfRange(arr,int formIndex,int toIndex) 将制定数组的指定长度复制到一个新数组中.






package hello;

import java.util.Arrays;

public class Main { 
	public static void main(String [] args)
	{
       int arr1[]=new int[]{1,2,3,4,5};
       int arr2[] = Arrays.copyOf(arr1, 3);
       int arr3[]=Arrays.copyOfRange(arr1,1, 3);
     // arr2[]复制源数组中从下标0开始的3个元素到目的数组,从下标0的位置开始存储。
       for(int i=0;i<arr1.length;i++)
           System.out.print(arr1[i]);//12345
		   System.out.println();
       
       for(int i=0;i<arr2.length;i++)
           System.out.print(arr2[i]);//123
			System.out.println();
			
	   for(int i=0;i<arr3.length;i++)
           System.out.print(arr3[i]);//23
			System.out.println();	
	}
}








(9)数组查询



binarySearch()方法提供了多种重载形式,用于满足各种类型数组的查找需要,binarySearch()有两种参数类型 二分搜索法来搜索指定数组,以获得指定对象
注意:调用前需要用sort()方法将数组排序,如果数组没有排序,则结果是不确定的,另外如果数组中含有多个带有指定值的元素,则无法保证找到的是哪一个。





binarySearch(Object[],Object key);   binarySearch(Object[].arr,int fromIndex,toIndex,Object key);如果指定的范围>=数组的长度,则会报异常。






如果key在数组中,则返回搜索值的索引;否则返回-1或者"-"(插入点)。插入点是索引键将要插入数组的那一点,即第一个大于该键的元素索引。存在时从0开始计数,不存在时从0开始计数.






package hello;

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		int arr[] = new int[] { 1, 8, 9, 11 };
		int x1 = Arrays.binarySearch(arr, 1);
		int x2 = Arrays.binarySearch(arr, 7);
		int x3 = Arrays.binarySearch(arr, 11);
		int x4 = Arrays.binarySearch(arr, 22);
		System.out.println("x1:" + x1 + ", x2:" + x2);
		System.out.println("x3:" + x3 + ", x4:" + x4);

		int x5 = Arrays.binarySearch(arr, 0, 2, 9);
		int x6 = Arrays.binarySearch(arr, 1, 3, 9);
		int x7 = Arrays.binarySearch(arr, 1, 3, 0);
		int x8 = Arrays.binarySearch(arr, 0, 3, 0);
		int x9 = Arrays.binarySearch(arr, 1, 3, 12);
		System.out.println("x5:" + x5 + ", x6:" + x6);
		System.out.println("x7:" + x7 + ", x8:" + x8 + " x9:" + x9);
	}
}
/*
 * 输出结果:
	x1:0, x2:-2
	x3:3, x4:-5
	x5:-3, x6:2
	x7:-2, x8:-1 x9:-4
 */





(10)冒泡排序



package hello;

public class Main {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 3, 5, 2 };
		System.out.print("冒泡前:");
		printArray(arr);// 打印数组元素
		bubbleSort(arr);// 调用排序方法
		System.out.print("冒泡后:");
		printArray(arr);
	}

	// 定义打印数组的方法
	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.print("\n");
	}

	// 定义对数组排序的方法
	public static void bubbleSort(int[] arr) {
		// 定义外层循环
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					// 以下三行代码用于交换两个元素
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			System.out.print("第" + (i + 1) + "轮排序后:");
			// 每轮比较后打印数组元素
			printArray(arr);
		}
	}
}



输出结果:

冒泡前:9 8 3 5 2 
第1轮排序后:8 3 5 2 9 
第2轮排序后:3 5 2 8 9 
第3轮排序后:3 2 5 8 9 
第4轮排序后:2 3 5 8 9 
冒泡后:2 3 5 8 9 

java 将一个数组拼接成数字join_java 将一个数组拼接成数字join_07