字符串数组的排序和查找
split(String);
String[] split(String,
ss = s0.split(".")
ss = s0.split(".
ints.split("",4)
StringSplit.java
java.util.*;
public class
StringSplit {
public static void
main(String[] args) {
&String s =
&String[] ss =
s.split("",4)
&for(int i=0;
System.out.print( ss[i] +",");
&System.out.println();
&String s0 = "Human.
beings. are. very. much.";
&ss = s0.split(".")
System.out.println("length="+ss.length);
&ss = s0.split(".
&for(int i=0;
System.out.println(ss[i] +"|");
ASCIICACC808ASCIIAAUnicode80CString
s.compareTo(String
s srt0s s&srt
StringCompare.java
java.util.*;
public class
StringCompare {
public static void
main(String[] args) {
&String[] s0 =
&"abort","books","being","are","very","
&String[] s1 =
"","","","","zero"
&String s =
&for(int i =0; i&5;
System.out.pareTo(s0[i]));
&for(int i =0; i&5;
System.out.pareTo(s1[i]));
&int big =
"".compareTo("");
&System.out.print("? "
&System.out.println(big&0);
1 -1 -1 -15 -21"acd""abort"1cb1
S1-1 -27766
? System.out.println(big&0)
Arrayssort
StringSort.java
java.util.*;
public class
StringSort {
public static void
main(String[] args) {
&String[] s0 =
&"abort","books","being","are","very","
&String[] s1 =
"","","","","zero"
&Arrays.sort(s0);
&System.out.println("Before
sorting:" );
&System.out.print(Arrays.asList(s0));
&Arrays.sort(s1);
&System.out.println("Before
sorting:" );
&System.out.print(Arrays.asList(s1));
[ much, abort, are,
being, books, very]
Arrays.binarySearch() &
”binarySearch()
Int binarySearch(s,
StringSearch.java
java.util.*;
public class
StringSearch {
public static void
main(String[] args) {
&String text
"You can’t look at Java as just a collection of features—some of
the features make no sense in isolation. You can use the sum of the
parts only if you are thinking about design, not simply coding. And
to understand Java in this way, you must understand the problems
with it and with programming in general. This book discusses
programming problems, why they are problems, and the approach Java
has taken to solve them. Thus, the set of features that I explain
in each chapter are based on the way I see a particular type of
problem being solved with the language. In this way I hope to move
you, a little at a time, to the point where the Java mindset
becomes your native tongue.";
&String[] s =
text.split(" ");
&String search =
&Arrays.sort(s);
&int pos =
Arrays.binarySearch(s,search);
System.out.println(search +"");
System.out.println(search +""+
&for(int i=28; i&32;
System.out.println(i +":"+ s[i]);
2832s[30]book
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java中怎么对数组中的字符串进行排序_百度知道
Java中怎么对数组中的字符串进行排序
方块K、Q、4、5、2、6、J、9、A、7,方块9例如一个数组 [ 梅花A,梅花A、10、小王, 黑桃2、K, 方块K, 小王, 红心3 ]怎么让它按照牌值3, 方块9、大王排序最后结果为 [ 红心3,小王 ]能给我定义一个方法的代码么, 黑桃2、8
提问者采纳
equals(&quot.equals(&quot/))
count = 14.equals(&quot.equals(&j&quot.toLowerCase().toLowerCase().toLowerCase();))
count = 17;))
count = 11;
else if())
count = 16;
else if(q&quot.equals(&大王&a&2&
else if(str.equals(&k&
count = Integer.substring())
count = 12.parseInt(str);小王&quot.toLowerCase();
else if(str。将要排序的字符串传进来;
count = 15;))
count = 13;按正常排序.toLowerCase().length()-1);
else if(str.equals(&quot；转换成整数就可以了public Integer Count (String str){
int count = 0;
return count
提问者评价
其他类似问题
为您推荐：
字符串的相关知识
其他1条回答
定义两个数组，使用类似键值对的方式
能详细说下么，具体代码怎样的，初学者求帮助(┬＿┬)
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁Java数组排序Arrays_sort，Comparator接口的用法 (一)_小组_ThinkSAAS
Java数组排序Arrays_sort，Comparator接口的用法 (一)
Java数组排序Arrays_sort，Comparator接口的用法 (一)
Java数组排序Arrays.sort，以及Comparator接口的用法
　有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法，但既然java包里有自带的Arrays.sort排序方法，在数组元素比较少的时候为何不用？
1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 };
　　Arrays.sort(intArray);
输出： [-23, 1, 3, 4]
2. 字符串排序，先大写后小写 String[] strArray = new String[] {"z","a","C"};　
Arrays.sort(strArray );　
输出： [C, a, z]
3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
　 输出： [a, C, z]
4. 反向排序， Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder());
输出：[z, a, C]
5. 忽略大小写反向排序 Case-insensitive reverse-order
　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
　　Collections.reverse(Arrays.asList(strArray));
　　输出： [z, C, a]
　　java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有必要去重复制造轮子。
　　Arrays类有一个静态方法sort,利用这个方法我们可以传入我们要排序的数组进去排序，因为我们传入的是一个数组的引用，所以排序完成的结果也通过这个引用的来更改数组.对于整数、字符串排序，jdk提供了默认的实现，如果要对一个对象数组排序，则要自己实现parator接口。
以下是一个简单的Demo：
package com.seimma.
import java.util.A
import java.util.C
public class ArraysDemo {
public static void main(String[] args) {
ArraysDemo sortArrays=new ArraysDemo();
sortArrays.sortIntArrays();
sortArrays.sortIntArraysIndex();
sortArrays.sortStringArrays();
sortArrays.sortInsensitiveArrays();
sortArrays.sortReverseArrays();
sortArrays.sortInsensitiveReverseArrays();
sortArrays.sortObjectArray();
* 对整型数组排序
void sortIntArrays(){
int [] arrays=new int[]{12,34,23,67,43,87,54};
System.out.println("整型排序前：");
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("整型排序后：");
Arrays.sort(arrays);
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
public void sortIntArraysIndex(){
int [] arrays=new int []{23,45,32,12,86,54,46,98,14,47,50};
System.out.println("排序前：");
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("对数组中的部分数据进行排序：");
Arrays.sort(arrays, 3, 8);
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
* 对字符串类型数组排序(区分大小写,小写排在后面)
public void sortStringArrays(){
String [] arrays = new String[] {"Java","Servlet","Apache","Hibernate","Tomcat"};
System.out.println("字符串排序前：");
for(int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("字符串排序后：");
Arrays.sort(arrays);
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
* 对字符串类型数组排序(严格排序，忽略大小写)
public void sortInsensitiveArrays(){
String [] arrays = new String[] {"Java","servlet","Apache","hibernate","Tomcat"};
System.out.println("字符串排序前：");
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("对字符串忽略大小写排序");
Arrays.sort(arrays, String.CASE_INSENSITIVE_ORDER);
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
* 对字符串反向排序
public void sortReverseArrays(){
String [] arrays = new String[] {"Java","Servlet","Apache","Hibernate","Tomcat"};
System.out.println("字符串反向排序前：");
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("对字符串反向排序");
Arrays.sort(arrays, Collections.reverseOrder());
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
* 忽略大小写反向排序
public void sortInsensitiveReverseArrays(){
String [] arrays = new String[] {"Java","servlet","Apache","hibernate","Tomcat"};
System.out.println("字符串忽略大小写反向排序前：");
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
System.out.println("字符串忽略大小写反向排序前后 ：");
Arrays.sort(arrays, String.CASE_INSENSITIVE_ORDER);
//对字符串忽略大小写排序
Collections.reverse(Arrays.asList(arrays));
//对忽略大小写后的字符串进行反向排序
for (int i = 0; i & arrays. i++) {
System.out.println(arrays[i]);
赞助商广告位1
赞助商广告位2
赞助商广告位4
赞助商广告位5
PHP开发框架
开发工具/编程工具
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
手机客户端
ThinkSAAS接收任何功能的Iphone(IOS)和Android手机的客户端定制开发服务
官方1群：【已满】
让ThinkSAAS更好，把建议拿来。java String数组sort排序错误
[问题点数：40分，结帖人muqianxiaoniu2018]
java String数组sort排序错误
[问题点数：40分，结帖人muqianxiaoniu2018]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。当前访客身份：游客 [
当前位置：
涉及到一个需要对String数组排序的问题，大家有什么好的方法么？
ps：jdk1.6中Arrays类未提供适用于String的排序！！！！
共有12个答案
<span class="a_vote_num" id="a_vote_num_
默认就是自然排序啊
<span class="a_vote_num" id="a_vote_num_
排序的算法谁知道你要什么算法？
我的算法简单
foreach遍历打印 &就是一种排序了
<span class="a_vote_num" id="a_vote_num_
没这个方法，你可以自己建立一个方法来实现啊，你也可以用集合中的TreeSet 方法来实现。它自动帮你把String排序。
<span class="a_vote_num" id="a_vote_num_
具体排序算法是根据String类中提供的compareTo方法实现的。
public int compareTo(String anotherString) {
int len1 =
int len2 = anotherString.
int n = Math.min(len1, len2);
char v1[] =
char v2[] = anotherString.
int j = anotherString.
if (i == j) {
int lim = n +
while (k & lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
while (n-- != 0) {
char c1 = v1[i++];
char c2 = v2[j++];
if (c1 != c2) {
return c1 - c2;
return len1 - len2;
这个方法提供了比较两个字符串大小的依据，然后Arrays.sort会根据这个依据进行排序
<span class="a_vote_num" id="a_vote_num_
引用来自“menxin”的答案
引用来自“风追云影”的答案
引用来自“menxin”的答案
引用来自“风追云影”的答案
Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数
可能我没表达清楚，我其实是想要个算法
你把具体的排序要求说一下，比如说按照字符串长度排，还是按照首字母。。具体的算法要有具体的要求，楼上的太复杂了，没必要
就是自然排序
package org.lizf.
import java.util.A
public class Sort {
public static void main(String[] args) {
String[] arr = {&b&, &c&, &a&, &f&, &a&,&z&,&x&,&f&,&l&};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//输出结果如下
[a, a, b, c, f, f, l, x, z]
<span class="a_vote_num" id="a_vote_num_
引用来自“风追云影”的答案引用来自“menxin”的答案引用来自“风追云影”的答案 Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数 可能我没表达清楚，我其实是想要个算法你把具体的排序要求说一下，比如说按照字符串长度排，还是按照首字母。。具体的算法要有具体的要求，楼上的太复杂了，没必要就是自然排序
<span class="a_vote_num" id="a_vote_num_
引用来自“menxin”的答案引用来自“风追云影”的答案 Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数 可能我没表达清楚，我其实是想要个算法你把具体的排序要求说一下，比如说按照字符串长度排，还是按照首字母。。具体的算法要有具体的要求，楼上的太复杂了，没必要
--- 共有 1 条评论 ---
人家要的不就是算法，再说这是JDK中已经提供的.....
(3年前)&nbsp&
<span class="a_vote_num" id="a_vote_num_
引用来自“menxin”的答案引用来自“风追云影”的答案 Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数 可能我没表达清楚，我其实是想要个算法
* Sorts the specified array of objects into ascending order, according to
* the {@linkplain Comparable natural ordering}
* of its elements.
All elements in the array
* must implement the {@link Comparable} interface.
Furthermore, all
* elements in the array must be &i&mutually comparable&/i& (that is,
* &tt&pareTo(e2)&/tt& must not throw a &tt&ClassCastException&/tt&
* for any elements &tt&e1&/tt& and &tt&e2&/tt& in the array).&p&
* This sort is guaranteed to be &i&stable&/i&:
equal elements will
* not be reordered as a result of the sort.&p&
* The sorting algorithm is a modified mergesort (in which the merge is
* omitted if the highest element in the low sublist is less than the
* lowest element in the high sublist).
This algorithm offers guaranteed
* n*log(n) performance.
* @param a the array to be sorted
ClassCastException if the array contains elements that are not
&i&mutually comparable&/i& (for example, strings and integers).
public static void sort(Object[] a) {
Object[] aux = (Object[])a.clone();
mergeSort(aux, a, 0, a.length, 0);
* Src is the source array that starts at index 0
* Dest is the (possibly larger) array destination with a possible offset
* low is the index in dest to start sorting
* high is the end index in dest to end sorting
* off is the offset to generate corresponding low, high in src
private static void mergeSort(Object[] src,
Object[] dest,
int off) {
int length = high -
// Insertion sort on smallest arrays
if (length & INSERTIONSORT_THRESHOLD) {
for (int i= i& i++)
for (int j=i; j&low &&
((Comparable) dest[j-1]).compareTo(dest[j])&0; j--)
swap(dest, j, j-1);
// Recursively sort halves of dest into src
int destLow
int destHigh =
int mid = (low + high) &&& 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);
// If list is already sorted, just copy from src to dest.
This is an
// optimization that results in faster sorts for nearly ordered lists.
if (((Comparable)src[mid-1]).compareTo(src[mid]) &= 0) {
System.arraycopy(src, low, dest, destLow, length);
// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = i & destH i++) {
if (q &= high || p & mid && ((Comparable)src[p]).compareTo(src[q])&=0)
dest[i] = src[p++];
dest[i] = src[q++];
<span class="a_vote_num" id="a_vote_num_
引用来自“风追云影”的答案 Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数 可能我没表达清楚，我其实是想要个算法
<span class="a_vote_num" id="a_vote_num_
Arrays.sort(数组)
String属于对象，Arrays中只提供基本数据类型数组排序，其他的都从属于Arrays.sort(Object[])。
其他的Object类型排序需要对象实现CompareTo接口，或使用实现了ComparaTor接口的对象作为Arrays.sort方法的第二个参数
更多开发者职位上
有什么技术问题吗？
menxin...的其它问题
类似的话题}