java数组排序的深入研究.docx

java数组排序的深入研究.docx

《java数组排序的深入研究.docx》由会员分享，可在线阅读，更多相关《java数组排序的深入研究.docx（26页珍藏版）》请在冰豆网上搜索。

java数组排序的深入研究

1:

StringBuffer

（1）用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了

一个字符串缓冲区类。

StringBuffer供我们使用。

（2）StringBuffer的构造方法

A:

StringBuffer（）

B:

StringBuffer（intsize）

C:

StringBuffer（Stringstr）

（3）StringBuffer的常见功能（自己补齐方法的声明和方法的解释）

A:

添加功能

B:

删除功能

C:

替换功能

D:

反转功能

E:

截取功能（注意这个返回值）

（4）StringBuffer的练习（做一遍）

A:

String和StringBuffer相互转换

String--StringBuffer

构造方法

StringBuffer--String

toString（）方法

B:

字符串的拼接

C:

把字符串反转

D:

判断一个字符串是否对称

小细节：

StringBuffer：

同步的，数据安全，效率低。

StringBuilder：

不同步的，数据不安全，效率高。

A:

String,StringBuffer,StringBuilder的区别

B:

StringBuffer和数组的区别?

（6）注意的问题：

String作为形式参数，StringBuffer作为形式参数。

2:

数组高级以及Arrays

（1）排序

A:

冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

同理，其他的元素就可以排好。

publicstaticvoidbubbleSort（int[]arr）{

for（intx=0;x

for（inty=0;y

if（arr[y]>arr[y+1]）{

inttemp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

}

B:

选择排序

把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。

同理，其他的元素就可以排好。

publicstaticvoidselectSort（int[]arr）{

for（intx=0;x

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

}

}

（2）查找

A:

基本查找

针对数组无序的情况

publicstaticintgetIndex（int[]arr,intvalue）{

intindex=-1;

for（intx=0;x

if（arr[x]==value）{

index=x;

break;

}

}

returnindex;

}

B:

二分查找（折半查找）

针对数组有序的情况（千万不要先排序，在查找）

publicstaticintbinarySearch（int[]arr,intvalue）{

intmin=0;

intmax=arr.length-1;

intmid=（min+max）/2;

while（arr[mid]!

=value）{

if（arr[mid]>value）{

max=mid-1;

}elseif（arr[mid]

min=mid+1;

}

if（min>max）{

return-1;

}

mid=（min+max）/2;

}

returnmid;

}

（3）Arrays工具类

A:

是针对数组进行操作的工具类。

包括排序和查找等功能。

B:

要掌握的方法（自己补齐方法）

把数组转成字符串：

排序：

二分查找：

（4）Arrays工具类的源码解析

（5）把字符串中的字符进行排序

举例：

"edacbgf"

得到结果

"abcdefg"

3:

Integer（掌握）

（1）为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型

byteByte

shortShort

intInteger

longLong

floatFloat

doubleDouble

charCharacter

booleanBoolean

（2）Integer的构造方法

A:

Integeri=newInteger（100）;

B:

Integeri=newInteger（"100"）;

注意：

这里的字符串必须是由数字字符组成

（3）String和int的相互转换

A:

String--int

Integer.parseInt（"100"）;

B:

int--String

String.valueOf（100）;

（4）其他的功能（了解）

进制转换

（5）JDK5的新特性

自动装箱基本类型--引用类型

自动拆箱引用类型--基本类型

把下面的这个代码理解即可：

Integeri=100;

i+=200;

（6）面试题

-128到127之间的数据缓冲池问题

4:

Character（了解）

（1）Character构造方法

Characterch=newCharacter（'a'）;

（2）要掌握的方法：

（自己补齐）

A:

判断给定的字符是否是大写

B:

判断给定的字符是否是小写

C:

判断给定的字符是否是数字字符

D:

把给定的字符转成大写

E:

把给定的字符转成小写

（3）案例：

统计字符串中大写，小写及数字字符出现的次数

二份查找

数组冒泡排序

选择排序

1数组排序冒泡排序

packagecn.itcast_01;

/*

*数组排序之冒泡排序：

*相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

*/

publicclassArrayDemo{

publicstaticvoidmain（String[]args）{

//定义一个数组

int[]arr={24,69,80,57,13};

System.out.println（"排序前：

"）;

printArray（arr）;

/*

//第一次比较

//arr.length-1是为了防止数据越界

//arr.length-1-0是为了减少比较的次数

for（intx=0;x

if（arr[x]>arr[x+1]）{

inttemp=arr[x];

arr[x]=arr[x+1];

arr[x+1]=temp;

}

}

System.out.println（"第一次比较后：

"）;

printArray（arr）;

//第二次比较

//arr.length-1是为了防止数据越界

//arr.length-1-1是为了减少比较的次数

for（intx=0;x

if（arr[x]>arr[x+1]）{

inttemp=arr[x];

arr[x]=arr[x+1];

arr[x+1]=temp;

}

}

System.out.println（"第二次比较后：

"）;

printArray（arr）;

//第三次比较

//arr.length-1是为了防止数据越界

//arr.length-1-2是为了减少比较的次数

for（intx=0;x

if（arr[x]>arr[x+1]）{

inttemp=arr[x];

arr[x]=arr[x+1];

arr[x+1]=temp;

}

}

System.out.println（"第三次比较后：

"）;

printArray（arr）;

//第四次比较

//arr.length-1是为了防止数据越界

//arr.length-1-3是为了减少比较的次数

for（intx=0;x

if（arr[x]>arr[x+1]）{

inttemp=arr[x];

arr[x]=arr[x+1];

arr[x+1]=temp;

}

}

System.out.println（"第四次比较后：

"）;

printArray（arr）;

*/

//既然听懂了，那么上面的代码就是排序代码

//而上面的代码重复度太高了，所以用循环改进

//for（inty=0;y<4;y++）{

//for（intx=0;x

//if（arr[x]>arr[x+1]）{

//inttemp=arr[x];

//arr[x]=arr[x+1];

//arr[x+1]=temp;

//}

//}

//}

/*

//由于我们知道比较的次数是数组长度-1次，所以改进最终版程序

for（intx=0;x

for（inty=0;y

if（arr[y]>arr[y+1]）{

inttemp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

System.out.println（"排序后：

"）;

printArray（arr）;

*/

//由于我可能有多个数组要排序，所以我要写成方法

bubbleSort（arr）;

System.out.println（"排序后：

"）;

printArray（arr）;

}

//冒泡排序代码

publicstaticvoidbubbleSort（int[]arr）{

for（intx=0;x

for（inty=0;y

if（arr[y]>arr[y+1]）{

inttemp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

}

//遍历功能

publicstaticvoidprintArray（int[]arr）{

System.out.print（"["）;

for（intx=0;x

if（x==arr.length-1）{

System.out.print（arr[x]）;

}else{

System.out.print（arr[x]+","）;

}

}

System.out.println（"]"）;

}

}

2数组排序选择排序

packagecn.itcast_02;

/*

*数组排序之选择排序：

*从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

*/

publicclassArrayDemo{

publicstaticvoidmain（String[]args）{

//定义一个数组

int[]arr={24,69,80,57,13};

System.out.println（"排序前：

"）;

printArray（arr）;

/*

//第一次

intx=0;

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

System.out.println（"第一次比较后：

"）;

printArray（arr）;

//第二次

x=1;

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

System.out.println（"第二次比较后：

"）;

printArray（arr）;

//第三次

x=2;

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

System.out.println（"第三次比较后：

"）;

printArray（arr）;

//第四次

x=3;

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

System.out.println（"第四次比较后：

"）;

printArray（arr）;

*/

/*

//通过观察发现代码的重复度太高，所以用循环改进

for（intx=0;x

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

}

System.out.println（"排序后：

"）;

printArray（arr）;

*/

//用方法改进

selectSort（arr）;

System.out.println（"排序后：

"）;

printArray（arr）;

}

publicstaticvoidselectSort（int[]arr）{

for（intx=0;x

for（inty=x+1;y

if（arr[y]

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

}

}

//遍历功能

publicstaticvoidprintArray（int[]arr）{

System.out.print（"["）;

for（intx=0;x

if（x==arr.length-1）{

System.out.print（arr[x]）;

}else{

System.out.print（arr[x]+","）;

}

}

System.out.println（"]"）;

}

}

3字符串中的数组排序

packagecn.itcast_03;

/*

*把字符串中的字符进行排序。

*举例：

"dacgebf"

*结果：

"abcdefg"

*

*分析：

*A:

定义一个字符串

*B:

把字符串转换为字符数组

*C:

把字符数组进行排序

*D:

把排序后的字符数组转成字符串

*E:

输出最后的字符串

*/

publicclassArrayTest{

publicstaticvoidmain（String[]args）{

//定义一个字符串

Strings="dacgebf";

//把字符串转换为字符数组

char[]chs=s.toCharArray（）;

//把字符数组进行排序

bubbleSort（chs）;

//把排序后的字符数组转成字符串

Stringresult=String.valueOf（chs）;

//输出最后的字符串

System.out.println（"result:

"+result）;

}

//冒泡排序

publicstaticvoidbubbleSort（char[]chs）{

for（intx=0;x

for（inty=0;y

if（chs[y]>chs[y+1]）{

chartemp=chs[y];

chs[y]=chs[y+1];

chs[y+1]=temp;

}

}

}

}

}

4二份查找

packagecn.itcast_04;

/*

*查找：

*基本查找:

数组元素无序（从头找到尾）

*二分查找（折半查找）:

数组元素有序

*

*分析：

*A:

定义最大索引，最小索引

*B:

计算出中间索引

*C:

拿中间索引的值和要查找的值进行比较

*相等：

就返回当前的中间索引

*不相等：

*大左边找

*小右边找

*D:

重新计算出中间索引

*大左边找

*max=mid-1;

*小右边找

*min=mid+1;

*E:

回到B

*/

publicclassArrayDemo{

publicstaticvoidmain（String[]args）{

//定义一个数组

int[]arr={11,22,33,44,55,66,77};

//写功能实现

intindex=getIndex（arr,33）;

System.out.println（"index:

"+index）;

//假如这个元素不存在后有什么现象呢?

index=getIndex（arr,333）;

System.out.println（"index:

"+index）;

}

/*

*两个明确：

*返回值类型：

int

*参数列表：

int[]arr,intvalue

*/

publicstaticintgetIndex（int[]arr,intvalue）{

//定义最大索引，最小索引

intmax=arr.length-1;

intmin=0;

//计算出中间索引

intmid=（max+min）/2;

//拿中间索引的值和要查找的值进行比较

while（arr[mid]!

=value）{

if（arr[mid]>value）{

max=mid-1;

}elseif（arr[mid]

min=mid+1;

}

//加入判断

if（min>max）{

return-1;

}

mid=（max+min）/2;

}

returnmid;

}

}

5不能使用的二分排序

packagecn.itcast_04;

/*

*注意：

下面这种做法是有问题的。

*因为数组本身是无序的，所以这种情况下的查找不能使用