第2章 Java编程基础_补充案例
第二章Java编程基础
案例2-1 定义不同类型的变量
一、案例描述
1、考核知识点
编号：00102005
名称：变量的定义及其数据类型
2、练习目标
了解变量的定义方式
掌握如何为不同类型的变量赋值
3、需求分析
变量用于存储程序运行期间的一些数据。为了加深初学者对变量的认识，本案例针对八种基本数据类型，分别定义了八个变量，并进行赋值操作。
4、设计思路（实现原理）
1）编写一个类Example01。
2）在Example01的main()方法中，针对八种基本数据类型，分别定义变量并赋值。
3）使用println语句打印变量的值。
二、案例实现
定义Example01类，其代码如下：
class Example01{
public static void main(String[] args) {
//定义字节变量
byte b = 12;
System.out.println(b);
//定义短整型变量
short s = 1234;
System.out.println(s);
//定义整数变量
int i = 12345;
System.out.println(i);
//定义长整型变量
long l = 12345678912345L;
System.out.println(l);
//定义单精度类型(7-8位的有效数字)
float f = 12.5F;
System.out.println(f);
//定义双精度类型(15-16
位的有效数字) double d = 12.5; System.out.println(d); //定义字符类型 char c = 'a';
//重新赋值,Java 中的字符采用的编码是Unicode 编码。占用2个字节。 c = '中';
System.out.println(c); //定义布尔类型
boolean flag = true; System.out.println(flag);
}
}
运行结果如图2-1所示。
图2-1 运行结果
三、案例总结
1、Java 对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，并且变量值的类型和变量类型必须一致，否则程序会报错。
2、byte 类型的变量存储的值必须是-27 ～ 27-1之间的整数。赋值的时候，尽量不要超出范围，如果超出可能损失精度。
3、定义变量的方式有两种，具体如下： 方式一：
数据类型 变量名 = 初始化值;
方式二：
数据类型 变量名; 变量名 = 初始化值;
案例2-2 变量的自动类型转换
一、案例描述
1、 考核知识点
编号：00102006
名称：变量的类型转换
2、练习目标
了解变量进行自动类型转换的条件
3、需求分析
变量的自动类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。为了明确哪些数据类型可以实现自动转换，本案例演示的是将一种数据类型的值赋给另外一种数据类型变量的情形。
4、设计思路（实现原理）
1）编写一个类Example02。
2）在类Example02中，定义byte类型的变量a，int类型的变量b，float类型的变量f，double 类型的变量d，其中，变量a的初始值为10，变量f的初始值为12.5f。
3）将变量a的值赋给变量b，变量a、b、f相加后的结果值赋给变量d。
4）使用println语句打印出变量b和变量d的值。
二、案例实现
定义Example02类，其代码如下：
class Example02
{
public static void main(String[] args)
{
//隐式转换
byte a = 10;
int b = a;
float f = 12.5F;
System.out.println(b);
double d = a+b+f;
System.out.println(d);
}
}
运行结果如图2-2所示。
图2-2运行结果
三、案例总结
1、要实现自动类型转换，必须同时满足两个条件，第一是两种数据类型彼此兼容，第二是目标类型的取值范围大于源类型的取值范围。
2、列出三种可以进行自动类型转换的情况，具体如下：
（1）整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给int、long类型的变量，int类型的数据可以赋值给long类型的变量。
（2）整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
（3）其它类型转换为double类型，如byte、char、short、int、long、float类型的数据可以赋值给double 类型的变量。
案例2-3 变量的强制类型转换
一、案例描述
1、考核知识点
编号：00102006
名称：变量的类型转换
2、练习目标
掌握不同数据类型间的强制类型转换
3、需求分析
强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。例如，两种类型彼此不兼容，或者目标类型取值范围小于源类型，都需要进行强制类型转换。为了明确两种不同类型的变量如何进行强制类型转换，本案例以int和byte类型为例，演示如何将int类型的变量强转为byte类型。
4、设计思路（实现原理）
1）编写一个类Example03
2）在Example03中的main()方法中定义一个int类型的变量i和byte类型的变量b，并将变量i 的值赋给变量b
3）使用println语句打印出变量b的值
二、案例实现
定义Example03类，其代码如下：
class Example03
{
public static void main(String[] args)
{
int i = 10;
byte b = (byte)i;
System.out.println(b);
}
}
运行结果如图2-3所示。
图2-3运行结果
三、案例总结
1、强制类型转换，具体格式如下：
目标类型变量 = （目标类型）值
2、在对变量进行强制类型转换时，会发生取值范围较大的数据类型向取值范围较小的数据类型的转
换，如将一个int类型的数转为byte类型，这样做极容易造成数据精度的丢失。int在内存中占用4个字节。byte类型的数据在内存中占用1个字节，当将变量i的数据在内存中占的内存大于1个字节时，前面3个高位字节的数据会丢失，数值也会发生改变。
案例2-4 变量的作用域
一、案例描述
1、考核知识点
编号：00102007
名称：变量的作用域
2、练习目标
了解变量的作用域
3、需求分析
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。为了让初学者熟悉变量的作用域，本案例将在三层的大括号内分别定义三个变量x、y、z，用输出语句输出变量的值，观察变量的作用域。
4、设计思路（实现原理）
1）编写一个类Example04
2）在main方法下定义变量x，并在每一层大括号内都使用一次x，观察x的作用域
3）在第一层括号内定义变量y,并在第二层括号内使用y，观察y的作用域
4）在第二层括号内定义z，并在第一层括号内使用z，观察z的作用域
二、案例实现
（1）定义Example04类，具体代码如下所示：
public class Example04 {
public static void main(String[] args) {
int x = 12;
{
int y = 96;
{
int z = 0; y = x; } System.out.println("x is " + x);
System.out.println("y is " + y);
z = x;
System.out.println("z is " + z); } System.out.println("x is " + x);
}
}
运行结果如图2-4所示。
图2-4 运行结果
（3）对上述代码进行修改，修改后的代码如下所示：
public class Example04 { public static void main(String[] args) { int x = 12; {
int y = 96;
{
int z = 0; y = x;
System.out.println("z is " + z); } System.out.println("x is " + x);
System.out.println("y is " + y);
}
System.out.println("x is " + x);
}
}
运行结果如图2-5所示。
图2-5运行结果
三、案例总结
1、第一次程序编译错误是因为程序在变量z的作用域外进行访问，所以程序找不到变量z。如果在变量z的作用域内访问z，程序就会编译成功。
2、x定义在main方法下，所有main方法下的任何位置都能够使用变量x。
3、y定义在第一层括号下，因为第二层括号在第一层括号内，所以在第二层括号内使用变量y也不会报错。
案例2-5 算术运算符
一、案例描述
1、考核知识点
编号：00102008
名称：算术运算符
2、练习目标
了解算术运算符的用法
3、需求分析
在程序中，经常会使用算术运算符进行四则运算，为了让初学者熟悉算术运算符的用法，本案例将以++、--、\等运算符为例，讲解不同算术运算符的作用。
4、设计思路（实现原理）
1）编写一个类Example05
2）在main方法下定义变量a，并赋值为2，定义变量b，并赋值为4；
3）首先运算表达式++a+b++，并把计算结果赋给变量x，然后将b/a的值赋给变量y；
4）输出变量a、b、x和y的值
二、案例实现
public class Example05 {
public static void main(String[] args) {
int a = 2;
int b = 4;
int x = ++a + b--;
int y=b/a;
System.out.println("a=" + a); System.out.println("b=" + b);
System.out.println("x=" + x); System.out.println("x=" + y);
}
}
运行结果如图2-6所示。
图2-6 运行结果
三、案例总结
1、在进行自增（++）和自减（--）的运算时，如果运算符（++或--）放在操作数的前面则是先进行自增或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。
2、在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。
案例2-6 赋值运算符
一、案例描述
5、 考核知识点
编号：00102009 名称：赋值运算符
6、 练习目标
了解赋值运算符的用法
7、 需求分析
在程序中，经常会使用赋值运算符， 它的作用就是将常量、变量或表达式的值赋给某一个变量。为了让初学者熟悉赋值运算符的用法，本案例将以+=运算符为例，讲解赋值运算符的作用。
8、 设计思路（实现原理）
1）编写一个类Example06
2）在main 方法下定义变量s ，并赋值为5，定义变量i ，并赋值为12； 3）使用赋值运算符计算s+=i++的值，并把计算结果赋给变量s 4）输出变量s 的值
二、案例实现
public class Example06 {
public static void main(String[] args) {
short s = 5;
int i = 12;
s += i++;
System.out.println("s = " + s);
}
}
运行结果如图2-7所示。
图2-7运行结果
三、案例总结
1、在赋值过程中，运算顺序从右往左，将右边表达式的结果赋值给左边的变量。
2、在Java中可以通过一条赋值语句对多个变量进行赋值，具体示例如下：
int a, b, c,d;
a =
b =
c =
d = 5; // 为四个变量同时赋值
案例2-7 比较运算符
一、案例描述
1、考核知识点
编号：00102010
名称：比较运算符
2、练习目标
了解比较运算符的用法
3、需求分析
在程序中，经常会使用比较运算符对两个变量或值进行比较，使用比较运算符的比较结果是一个布尔类型的值。为了让初学者熟悉比较运算符的用法，本案例将以==、>=、<=、!=比较运算符为例，讲解比较运算符的用法。
4、设计思路（实现原理）
1）编写一个类Example07
2）在main方法下定义变量x、y，并依此赋值为0、1；
3）使用==运算符比较字符'a' == 97，输出运算结果；
4）使用>=运算符比较'a' >= 100，输出运算结果； 5）使用<=运算符比较x <= y ，输出运算结果； 6）使用!=运算符比较x != y ，输出运算结果；
二、案例实现
public class Example07 { public static void main(String[] args) {
int x = 0; // 定义变量x ，初始值为0 int y = 1; // 定义变量y ，初始值为0
System.out.println('a' == 97); //判断字符a 是否等于97 System.out.println('a' >= 100); //判断字符a 是否大于100 System.out.println(x <= y); //判断x 是否小于等于y System.out.println(x != y); //判断x 是不是不等于y
}
}
运行结果如图2-8所示。
图2-8 运行结果
三、案例总结
1、使用比较运算符计算的表达式，返回的结果是一个布尔类型的值
2、不能将比较运算符“==”误写成赋值运算符“=”。
案例2-8 逻辑运算符
一、案例描述
1、 考核知识点
编 号：00102011
名 称：逻辑运算符
2、 练习目标
了解逻辑运算符的运算规则
掌握如何使用逻辑运算符进行逻辑运算
3、 需求分析
逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。为了加深初学者对逻辑运算符的印象，本案例定义一个变量x，使用逻辑运算符连接表达式x>1和x<5，通过运行结果分析逻辑运算符的运算规则。
4、设计思路（实现原理）
1）编写一个类Example08
2）在main方法下定义变量x，其初始值为3
2）使用逻辑运算符连接两个布尔型的表达式x>1和x<5
3）使用println语句输出运算结果
二、案例实现
定义Example08类，其代码如下：
class Example08
{
public static void main(String[] args)
{
int x = 3;
System.out.println(x>1 & x<5);
System.out.println(x<1 | x<5);
System.out.println(x>1 ^ x>5);
System.out.println(!(x<1));
}
}
运行结果如图2-9所示。
图2-9运行结果
三、案例总结
在使用逻辑运算符的过程中，需要注意以下几个细节：
1、逻辑运算符可以针对结果为布尔值的表达式进行运算。如：x > 3 && y != 0。
2、运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为false时，右边的表达式不会进行运算，因此“&&”被称作短路与。
3、运算符“|”和“||”都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。同与操作类似，“||”表示短路或，当运算符“||”的左边为true 时，右边的表达式不会进行运算。
4、运算符“^”表示异或操作，当运算符两边的布尔值相同时（都为true或都为false），其结果为false。
当两边布尔值不相同时，其结果为true。
案例2-9 位运算符
一、案例描述
1、考核知识点
编号：00102012
名称：位运算符
2、练习目标
了解位运算符的运算规则
掌握使用位运算符进行逻辑运算
3、需求分析
位运算符是针对二进制数的每一位进行运算的符号，它是专门针对数字0和1进行操作的。请使用不同的位运算符对十进制的3和4进行运算。
4、设计思路（实现原理）
1）将十进制3和4换算成二进制数
2）使用不同的位运算符对3和4进行位运算
3）编写一个类Example09
4）在main方法下输出3和4进行不同的位运算后的结果
5）对比运算结果，判断运算是否正确
二、案例实现
1、将3和4换算成二进制数：3的二进制为00000011；4的二进制为00000100
2、&:位与运算：
00000100
&
00000011
—————————
00000000
所以，4&3=0
3、|:位或运算符
00000100
|
00000011
—————————
00000111
所以，4 | 3=7
4、^:异或运算符
00000100
^
00000011
—————————
00000111
所以，4 ^ 3=7
5、~:按位取反
00000011 ~:11111100 原码:1 1111100 反码:1 0000011 补码:1 0000100 所以：~3=-4
6、<<:左移
00000011 <<2 ————————— 00001100
所以：3<<2=12
7、定义Example07类，其代码如下：
class Example09 { public static void main(String[] args) { System.out.println(4&3); System.out.println(4|3); System.out.println(4^3); System.out.println(~3);
System.out.println(3<<2);
}
}
运行结果如图2-10所示。
图2-10 运行结果
由此可见，二进制位运算与程序运算的结果一致。
三、案例总结
Java
案例2-10 运算符的优先级
一、案例描述
1、考核知识点
编号：00102013
名称：运算符的优先级
2、练习目标
掌握运算符之间的优先级
3、需求分析
当使用不同的运算符进行运算时，应该按照一定的顺序进行运算，即根据运算符的优先级进行运算。为了让初学者掌握运算符的优先级，本案例将通过表达式的运算，讲解运算符的优先级。
4、设计思路（实现原理）
1）编写一个类Example10
2）在main方法中定义两个int型变量x和y
3）将表达式3>2*x?x++:--x赋值给y
4）用输出语句分别输出变量x和y的值
二、案例实现
定义Example10类，其代码如下：
class Example10
{
public static void main(String[] args)
{
int x=1;
int y=0;
y=3>2*x?x++:--x;
System.out.println(x);
System.out.println(y);
}
}
运行结果如图2-11所示。
图2-11运行结果
三、案例总结
1、本案例中表达式的运算过程如下所示：
1）在表达式y=3>2*x?x++:--x；中赋值运算符=的优先级最低，所以要先运算=右侧的表达式；
2）？：为三元运算符，该运算符的优先级较低，要先运算？前面的表达式。
3）*的优先级比>的高，所以3>2*1为true。按照三元运算符的运算规则表达式等价于y=x++ 4）x++的++在后面，所以要先进行其它运算再自增，最后结果为x=2,y=1
使用括号“()”来实现想要的运算顺序，以免产生歧义。
案例2-11 if条件语句
一、案例描述
1、考核知识点
编号：00102014
名称：if条件语句
2、练习目标
掌握if条件语句的语法格式
了解if条件语句的执行流程
3、需求分析
if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。为了让初学者掌握if…else if…else语句的用法，本案例将使用if…else if…else语句实现判断某月是哪个季节的功能。
设计思路（实现原理）
1）编写一个类Example11
2）定义一个变量month用于存储月份。
3）用if条件语句，判断这个月份在哪一个季节并输出结果，如：春季是3、4、5月，夏季是6、
7、8月，秋季是9、10、11月，冬季是12、1、2月
4）由于一年只有12个月，所以要过滤除1-12以外的月份值
二、案例实现
定义Example11类，其代码如下：
class Example11
{
public static void main(String[] args)
{
int month = 3;
if(month == 3 || month == 4 || month == 5)
{
System.out.println(month+"月是春季");
}
else if(month == 6 || month == 7 || month ==8)
{
System.out.println(month+"月是夏季");
}
else if(month == 9 || month == 10 || month ==11)
{
System.out.println(month+"月是秋季");
}
else if(month == 1 || month == 2 || month ==12)
{
System.out.println(month+"月是冬季");
}
else
{
System.out.println("没有这个月份");
}
}
}
运行结果如图2-12所示。
图2-12运行结果
三、案例总结
1、f…else if…else语句用于对多个条件进行判断，进行多种不同的处理。if…else if…else语句具体语法格式如下：
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
if…else if…else语句的执行流程如图2-13所示。
图2-13流程图
2、因为一年只有12个月，所以当month>12时是不符合逻辑的数据，这时会打印“没有这个月份”。在编程过程中，经常要考虑程序在实际环境下是否符合逻辑需求。
3、“||”表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。所以只要符合三个条件中的一个就会被判断为这个季节。
案例2-12 switch条件语句
一、案例描述
1、考核知识点
编号：00102015
名称：switch条件语句
2、练习目标
熟悉switch条件语句的语法格式
了解switch条件语句的特点
3、需求分析
switch 条件语句也是一种很常用的选择语句，和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。为了让初学者熟悉switch 条件语句，本案例将使用switch 条件语句实现判断选择题对错的功能。
4、设计思路（实现原理）
1）编写一个类Example12
2）定义一个变量answer用于存储答案选项
3）用switch条件语句判断如果变量answer为B则正确，其它则错误
4）如果变量answer不等于ABCD四个选择则打印“不存在此选项”
二、案例实现
定义Example12类，其代码如下：
class Example12
{
public static void main(String[] args)
{
char answer = 'B';
switch(answer)
{
case 'A':
System.out.println("A错误");
break;
case 'B':
System.out.println("B正确");
break;
case 'C':
System.out.println("C错误");
break;
case 'D':
System.out.println("D错误");
break;
default:
System.out.println("不存在此选项");
}
}
}
运行结果如图2-14所示。
图2-14运行结果
三、案例总结
1、switch语句的执行流程是：根据表达式的值查找与其匹配的项,如果有匹配项,则执行该匹配项下面的语句。如果没有匹配项，就会执行default后面的语句。
2、switch关键字后括号内的表达式可以是byte,short,int,char四种类型；在JDK5以后表达式可以是枚举；在.JDK7以后表达式可以是字符串。
3、switch语句只适合判断若干值的情况，不适合判断范围。
4、if和switch都可以判断值的情况，这时应该使用switch语句，因为switch的效率比if语句高。
案例2-13 while循环语句
一、案例描述
1、考核知识点
编号：00102016
名称：while循环语句
2、练习目标
掌握while循环语句的语法格式和使用
了解while循环语句的特点
3、需求分析
while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环才会结束。为了让初学者熟悉while语句，本案例将使用while语句实现统计1-10以内奇数的功能。
4、设计思路（实现原理）
1）编写一个类Example13
2）定义一个变量x为1，用while语句循环条件为x<=10
3）在while循环中，使用表达式x%2判断是否为奇数，如果为奇数，则变量count的值加1。二、案例实现
定义Example13类，其代码如下：
class Example13
{
public static void main(String[] args)
{
int x = 1;
int count;
count = 0;
while(x<=10)
{
if(x%2==1)
{
count++;
System.out.println(x);
}
x++;
}
System.out.println("count="+count);
}
}
java 排序面试题
一道常考的javaSE面试题 上周一,.NET班有四个同学去面试，面试题是一道排序题，不管用什么方式做出结果就行。 就这道题我也想些想法，当时他们和我说完，我在想用什么方法可以实现。毕竟现在javaSE都忘的差不多了，现在主要学的还是javaEE方面。年前学习JSP和SERVLET一片的知识，到了年后主要学习三大框架、ajax、jquery和XML等。不过当时出现脑中的算法只有：java.util包中定义的Arrays类和冒泡法。 下面就拿上面方说的那两种方法具体说说。 在JDK的java.util包中定义的Arrays类提供了多种数据操作方法，实现了对数组元素的排序、填充、转换、增强检索和深度比较等功能，所以的这些方法都是static的，下面介绍对数组元素进行排序的方法。数组元素的排序通常是指一维数值型数组元素按升序排序，偶尔也会涉及一维String数组排序，一般来说，多维和其他引用类型的元素数组排序使用意义不大。 Arrays类中的sort()的格式： public static void sort([] a); 案例1： JDK的java.util包中定义的Arrays类提供了排序方法 一维数组排序： Java代码 1.package cn.z_xiaofei168.sort; 2. 3.import java.util.Arrays; 4. 5.public class TestArraySort { 6. 7./** 8. * @author z_xiaofei168 9. */ 10.public static void main(String[] args) { 11.int[] arr = { -1, -3, 5, 7, 9, 2, 4, 6, 8, 10 }; 12. System.out.print("整数排序前："); 13. displayIntArr(arr); 14. Arrays.sort(arr); 15. System.out.print("整数排序后："); 16. displayIntArr(arr); 17.
排序算法原理与实现(java)
Java程序员必知的8大排序<合肥软件培训> [来源：本站| 日期：2012年12月24日| 浏览173次] 字体:[大中小] 8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 //从小到大 package com.njue;
2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i 下面是377个Java的例子。如果你是牛人，看看你能做出多少？ 如果有人不相信这些例子都是Java做的，可以看看清华大学的《Java范例开发大全》实例1开发第一个Java程序 实例2自动提升 实例3自动转换 实例4常用基础类型之强制转换 实例5算术运算符 实例6关系运算符 实例7逻辑运算符 实例8位运算符 实例9移位运算符 实例10转型运算符 实例11常量与变量 实例12各种进制的转换 实例13 Java中的进制与移位运算符 实例14判断输入的年份是否为闰年 实例15抽奖活动 实例16xx乘法表 实例17如何列出素数 实例18 Java中的递归 实例19男生女生各多少人 实例20求xx数 实例21求任意一个正数的阶乘 实例22求n的n次方 实例23利用for循环输出几何图形 实例24xx 实例25求1到100之间的和 实例26存上100元需要多少天 实例27输出100之间的所有偶数 实例28如何判断回文数字 实例29输出100之间的所有奇数 实例30求最大的随机数 实例31判断字母分类 实例32优良及差 实例33打印任意一年日历 实例34一年四季的划分 实例35除0发生的算术异常（ArithmeticException） 实例36数组下标越界异常（ArrayIndexOutOfBoundsException）实例37数组元素类型不匹配异常（ArrayStoreException） 实例38强制类型转换异常（ClassCastException） 实例39索引越界异常（IndexOutOfBoundsException） 实例40空指针异常（NullPointerException） 一、插入排序 1、基本思想 插入排序（以升序为例）的基本操作是将一个数插入到一个已经排好序的数据序列中，插入后的数据序列是有序的并且元素个数加一。插入排序的主要思想是： 假设要排序的数组为A[]元素个数为n，将这个数组分为两个部分前n-1个元素和最后一个元素，将最后一个元素插入到已经排好序的n-1个元素中的合适的位置。 InsertSort(A[n]) //对A[n]进行插入排序 { for i=1 to n divide(A[i-1],a[i]) //将A[i]分为两部分，前i-1个元素和最后一个元素 Insert(a[i],A[i-1])//将最后一个元素插入到排好序的前i-1个元素中 } 2、算法复杂度分析 插入排序存在着最好情况和最坏情况，最好的情况是已经是排好序的了，这时只需比较n-1次即可；最坏的情况是序列是降序的需要排成升序的，那么此时就需要比较n(n-1)/2。插入排序的赋值操作是比较操作的次数加上n-1次。平均来说插入排序的算法复杂度为O(n2)。 3、编程实现 public static void InsertSort(int[] A){ for(int i=1;i Java程序员必知的8大排序(上) 本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文 AD：8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 1package com.njue; 2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,3 4,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i 冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序 一、一个int类型数组按升序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayAesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); } public int[] sortArrayAesc(int[] temps){ for (int i = 0; i < temps.length; i++) { for (int j = i+1; j < temps.length; j++) { if (temps[i] > temps[j]) { int temp; temp = temps[i]; temps[i] = temps[j]; temps[j] = temp; } } } return temps; } } 二、一个int类型数组按降序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayDesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); } JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i 此文中的七种排序算法为个人总结，程序均在eclipse中验证成功，可供参考 package sort; /* * 各种排序方法总结 */ public class Sort { public static void main(String[] args) { int[] array={4,9,6,7,2,3,1,5,8,0}; Sort.heapSort(array); for(int i=0;i Java程序员必知的8大排序本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 1.package com.njue; 2. 3.public class insertSort { 4.public insertSort(){ 5. inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17, 18,23,34,15,35,25,53,51}; 6.int temp=0; 7.for(int i=1;i ** 大家好，我现在正在学习，虽然在这之前我已经学习过一遍了，但是现在再重新来学，才发现以前学地太肤浅了，而且学地质量也很不好，所以，现在我又重新站在了新地起跑线上，开始了我地学习之旅，喜欢地朋友和想学习地朋友来和我一起前进吧.我会及时地把自己学地一些东西总结出来，并传送到文库中和大家一起分享地. 所以地时候到了，，！ （我地号，愿意交流地同学可以加我呦) 中地几种排序方法：冒泡排序，选择排序，插入排序和快速排序.下面是我当初开始学时地一些源代码，简单易懂，拿出来分享给大家，希望对刚接触地人能够有所帮助.b5E2R。 在此，也和大家共勉一下：相信自己，用心学习，大胆创新！ * .*首先是冒泡排序，冒泡排序地思想是：数组中地相邻地两个数进行比较，如果后面地数比前面地数大，则两个数进行交换，每完成一次循环，最大地那个数就排在了最后面；以此类推，在第次循环后，数组中地个数就排好了.下面是源代码p1Ean。 * { ([] ){ [] {}; ( <){ ([]); } ( <){ ( <){ ([]<[]){ []; [][]; []; } } } (); ( <){ ([]); } } } *.其次是选择排序.选择排序地思想是记录下数组中最小地那个数地下标，然后与第一个数进行交换，以此类推，直到 排好序为止.下面是源代码DXDiT。* { ([] ){ [] {}; ( <){ ([]); } 排序 ( <){ (); (); } (); ( <){ ([]); } } 找到最小地数地下标 ([] ){ []; ; ( <){ ([]<){ []; ; } } ; } 两个数进行交换 ([] ){ []; [][]; []; } } *.然后是插入排序.插入排序地基本思想是：新建一个数组，将需要排序地数组地第一个元素先放到新数组中去，然后把剩下地元素有序地、依次插入到新数组中去.下面是源代码RTCrp。 * { ([] ){ [] {}; 本文由我司收集整编，推荐下载，如有疑问，请与我司联系 java 中数组常见的排序问题整理 2016/03/13 0 span > 1.选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的 起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。 如图所示：数组array 有5 个元素 首先，array[0]与array[1]比较大小，如果array[0] array[1],则将两元素互换位置，然后再将array[0]与array[2]进行比较，一次进行下去，当第一轮循环完成，则 array[0]是数组中最小的元素。然后开始拿array[1]与array[2]进行比较，依次下去， 比较到最后即可。 程序代码实现如下： public void SelectionSort(int[] array){for(int i=0;i array.length-1;i++){for(int j=i+1;j array.length;j++){int temp;if(array[i] array[j]){temp = array[i];array[i]=array[j];array[j]=temp;}}}}2.冒泡排序：它重复地走访过要排序的数 列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作 是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。下面用一张图 来详细说明冒泡的原理。如图： 数组array 有五个元素，int[] array={7,5,12,9,2}; 第一步还是和选择排序一样，先是array[0]和array[1]进行比较，如果array[0] array[1],两个元素互换位置，即array[0]=5,array[1]=7；第二步，array[1]和array[2]进行比较大小，array[1] array[2],位置不变；第三步，array[2]和array[3]比较，array[2] array[3],位置互换；array[3]与array[4]比较，array[3] array[4],位置互换，第一轮循环结束，我们会发现，数组的最后一个元素是数组中最大的。第一轮循环完成后的数 组变成如下图所示： 接下来继续又从array[0]和array[1]开始比较，重复下去。第一轮比较得出了最 Java排序算法 1）分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（箱排序、基数排序） 所需辅助空间最多：归并排序 所需辅助空间最少：堆排序 平均速度最快：快速排序 不稳定：快速排序，希尔排序，堆排序。 1）选择排序算法的时候 1.数据的规模； 2.数据的类型； 3.数据已有的顺序 一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。 3）总结： ——按平均的时间性能来分： 1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好； 2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此； 3）时间复杂度为O(n)的排序方法只有，基数排序。 当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。 ——按平均的空间性能来分（指的是排序过程中所需的辅助空间大小）： 1）所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)； 2）快速排序为O(log n )，为栈所需的辅助空间; 3）归并排序所需辅助空间最多，其空间复杂度为O(n ); 4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。 ——排序方法的稳定性能： 1）稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。 2）当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。 3）对于不稳定的排序方法，只要能举出一个实例说明即可。 4）快速排序，希尔排序和堆排序是不稳定的排序方法。 4）插入排序： 包括直接插入排序，希尔插入排序。 直接插入排序：将一个记录插入到已经排序好的有序表中。 1, sorted数组的第0个位置没有放数据。 java中常用的七大排序算法 这段时间闲了下来，就抽了点时间总结了下java中常用的七大排序算法，希望以后可以回顾！ 1.插入排序算法 插入排序的基本思想是在遍历数组的过程中，假设在序号i之前的元素即[0..i-1] 都已经排好序，本趟需要找到i对应的元素x 的正确位置k ，并且在寻找这个位置k 的过程中逐个将比较过的元素往后移一位，为元素x “腾位置”，最后将k 对应的元素值赋为x ，一般情况下，插入排序的时间复杂度和空间复杂度分别为O(n2) 和O(1)。 /** * @paramint[] 未排序数组 * @return int[] 排完序数组 */ publicint[] sortInsert(int[] array){ for(inti=1;i public class PaiXu{ /** * @author zongyanshan * @since 20130725 */ public static void main(String[] args) { // TODO Auto-generated method stub int[] num = { 2, 9, 3, 1, 7, 4 }; // PopSortTest.popSort(num); // PopSortTest.chioseSort(num); // PopSortTest.insertSort(num); PopSortTest.shellSort(num); for (int i = 0; i < num.length; i++) { System.out.println(num[i]); } } // 冒泡排序法 public static int[] popSort(int num[]) { int temp; for (int i = 0; i < num.length; i++) { for (int j = 0; j < num.length - 1; j++) { temp = num[j]; if (num[j + 1] > num[j]) { num[j] = num[j + 1]; num[j + 1] = temp; } } } return num; } // 选择排序法 public static void choiceSort(int num[]) { int temp = 0; for (int i = 0; i < num.length; i++) { for (int j = i; j < num.length - 1; j++) { temp = num[i]; if (num[j + 1] > temp) { int temp2 = temp; temp = num[j + 1]; num[j + 1] = temp2; } 以下内容节选自Java私塾自编经典教材： 下面是Java实现的一些常见排序算法。 1：冒泡排序 对几个无序的数字进行排序，比较常用的方法是冒泡排序法。冒泡法排序是一个比较简单的排序方法，在待排序的数列基本有序的情况下排序速度较快。 基本思路：对未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。 可以看出如果有N个元素，那么一共要进行N-1轮比较，第I轮要进行N-I次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较） 示例如下： public class Test { public static void main(String[] args) { //需要排序的数组，目前是按照升序排列的 int a[] = new int[5]; a[0] = 3; a[1] = 4; a[2] = 1; a[3] = 5; a[4] = 2; //冒泡排序 for(int i=0;i 1.冒泡排序法 /** *功能：冒泡排序法 *思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的排序码， *，若发现逆序这交换，使得排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标） *较小的单元，，就像水底下的气泡一样逐渐向上冒。 *作者：徐守威 */ package com.xushouwei; public class T4 { /** *@param args */ public static void main(String[] args) { // TODO Auto-generated method stub int arr1[]={1,6,0,-1,9,-100,90}; //开始排序,创建一个Bubble类 Bubble bubble=new Bubble(); bubble.sort(arr1); //输出最后结果 for(int i=0;i //排序方法 public void sort(int arr[]) { //第一层循环用来指定排序的次数 //定义一个临时变量来存放交换的值 int temp=0; for(int i=0;i java排序算法大全 为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter 各种排序算法总结 排序算法是最基本最常用的算法，不同的排序算法在不同的场景或应用中会有不同的表现，我们需要对各种排序算法熟练才能将它们应用到实际当中，才能更好地发挥它们的优势。今天，来总结下各种排序算法。 下面这个表格总结了各种排序算法的复杂度与稳定性： 各种排序算法复杂度比较.png 冒泡排序 冒泡排序可谓是最经典的排序算法了，它是基于比较的排序算法，时间复杂度为O(n^2)，其优点是实现简单，n较小时性能较好。 ?算法原理 相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小的数就被排在了第一位，第二趟也是如此，如此类推，直到所有的数据排序完成 ?c++代码实现 1.void bubble_sort(int arr[], int len) 2.{ 3.for (int i = 0; i < len - 1; i++) 4. { 5.for (int j = len - 1; j >= i; j--) 6. { 7.if (arr[j] < arr[j - 1]) 8. { 9.int temp = arr[j]; 10. arr[j] = arr[j - 1]; 11. arr[j - 1] = temp; 12. } 13. } 14. } 15.} 选择排序 ?算法原理 先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 ?c++代码实现 1.void select_sort(int arr[], int len) 2. { 3.for (int i = 0; i < len; i++) 4. { 5.int index = i; 6.for (int j = i + 1; j < len; j++) 7. { 8.if (arr[j] < arr[index]) 9. index = j; 10. } 11.if (index != i) 12. { 13.int temp = arr[i]; 14. arr[i] = arr[index]; 15. arr[index] = temp; 16. } 17. } 18. } 插入排序 ?算法原理 将数据分为两部分，有序部分与无序部分，一开始有序部分包含第1个元素，依次将无序的元素插入到有序部分，直到所有元素有序。插入排序又分为直接插入排序、二分插入排序、链表插入等，这里只讨论直接插入排序。它是稳定的排序算法，时间复杂度为O(n^2) ?c++代码实现 1.void insert_sort(int arr[], int len) 2. { java排序123 为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter 其他拓扑排序 | 排序网络 | Bitonic sorter | Batcher odd-even mergesort | Pancake sorting 一、排序 1.冒泡法： .. 使用冒泡排序为一列数字进行排序的过程分类排序算法数据结构数组最差时间复杂度O(n2)最优时间复杂度O(n)平均时间复杂度O(n2)最差空间复杂度O(n) total, O(1) auxiliary public static void sort(Comparable[] a) { int N = a.length; for(int i=0;i a[from] = a[to]; a[to] = t; } 判断是否已经有序： public static boolean isSorted(Comparable[] a) { for(int i=1;i《Java范例开发大全》
java中的各种排序案例
Java程序员必知的8大排序(上)
JAVA数组的排序方法实例
java二分法查找案例与数组排序案例
JAVA中运用数组的四种排序方法
java的七种经典排序
java中8大排序方法
java中几种简单的排序
java中数组常见的排序问题整理
Java各种排序算法
java中常用的七大排序算法
用java编写的排序程序
Java实现的常见排序算法
冒泡排序法、选择排序法、插入排序法(java案例详解)
java排序算法大全
最新各种排序算法总结
java排序123
排序方法及其例子