java编程：任意给出一个字符串数组，按照字母的顺序将其排序输出。

Posted 2023-04-28

可用排序算法 compareTo()

参考技术A //JAVA原装的String比较方法
/**
* Compares two strings lexicographically.
* The comparison is based on the Unicode value of each character in
* the strings. The character sequence represented by this
* <code>String</code> object is compared lexicographically to the
* character sequence represented by the argument string. The result is
* a negative integer if this <code>String</code> object
* lexicographically precedes the argument string. The result is a
* positive integer if this <code>String</code> object lexicographically
* follows the argument string. The result is zero if the strings
* are equal; <code>compareTo</code> returns <code>0</code> exactly when
* the @link #equals(Object) method would return <code>true</code>.
* <p>
* This is the definition of lexicographic ordering. If two strings are
* different, then either they have different characters at some index
* that is a valid index for both strings, or their lengths are different,
* or both. If they have different characters at one or more index
* positions, let <i>k</i> be the smallest such index; then the string
* whose character at position <i>k</i> has the smaller value, as
* determined by using the < operator, lexicographically precedes the
* other string. In this case, <code>compareTo</code> returns the
* difference of the two character values at position <code>k</code> in
* the two string -- that is, the value:
* <blockquote><pre>
* this.charAt(k)-anotherString.charAt(k)
* </pre></blockquote>
* If there is no index position at which they differ, then the shorter
* string lexicographically precedes the longer string. In this case,
* <code>compareTo</code> returns the difference of the lengths of the
* strings -- that is, the value:
* <blockquote><pre>
* this.length()-anotherString.length()
* </pre></blockquote>
*
* @param anotherString the <code>String</code> to be compared.
* @return the value <code>0</code> if the argument string is equal to
* this string; a value less than <code>0</code> if this string
* is lexicographically less than the string argument; and a
* value greater than <code>0</code> if this string is
* lexicographically greater than the string argument.
*/
public int compareTo(String anotherString)
int len1 = count;
int len2 = anotherString.count;
int n = Math.min(len1, len2);
char v1[] = this.toCharArray();;
char v2[] = anotherString.toCharArray();
int i = offset;
int j = anotherString.offset;

if (i == j)
int k = i;
int lim = n + i;
while (k < lim)
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2)
return c1 - c2;

k++;

else
while (n-- != 0)
char c1 = v1[i++];
char c2 = v2[j++];
if (c1 != c2)
return c1 - c2;



return len1 - len2;
参考技术B 必须用compareTo()吗
不是必须的话这样就行

import java.util.*;

public class TextString

public static void main(String[] args)
Scanner input = new Scanner(System.in);
String s = input.nextLine();

char[] ch = s.toCharArray();
Arrays.sort(ch);
System.out.println(ch);


参考技术C public class MyClass
public void Sort(String[] data)

int l=data.length;
String tmp;
for(int i=0;i<l;i++)

for(int j=i+1;j<l;j++)
if(data[i].compareToIgnoreCase(data[j])<0) //注意此处是忽略大小写的比较

tmp=data[i];
data[i]=data[j];
data[j]=tmp;

System.out.println(data[i]);


参考技术D public static void getSort(String str)
char []chs = str.toCharArray();
Arrays.sort(chs);
System.out.println(chs);
第5个回答  2008-11-17 这个都能用那还怕什么啊?直接用一个char【】数组就可以了啊，冒泡法排序啊，最简单的。

Java编程实现中英混合字符串数组按首字母排序的方法

本文实例讲述了Java编程实现中英混合字符串数组按首字母排序的方法。分享给大家供大家参考，具体如下：

在Java中对于字符串数组的排序，我们可以使用Arrays.sort（String[]）方法很便捷的进行排序。例如：

String[] arrays = new String[]  "gyu", "sdf", "zf", "大同", "收到", "地方", "三等分", "的人", "反对高铁", "泛代数", "上的投入", "和国家" ;
/*设置语言环境*/
Comparator<Object> com = Collator.getInstance(java.util.Locale.CHINA);
Arrays.sort(arrays, com);
for (String item:arrays) 
 System.out.print(item+" ");

输出的结果为：“gyu sdf zf 大同 的人 地方 反对高铁 泛代数 和国家 三等分 上的投入 收到”；在Java中排列的顺序是按照数字->英文->汉字进行排序的，这种排序方式可以满足部分要求，但很多情况下我们并不希望这样排列！例如Anroid中的通讯录，音乐播放列表等等，这些情形下我们希望英文首字母和中文拼音首字母一样的排列在一起以方便查询。由于这类排序算法很复杂，例如首字母相同的字符串还要接着比较第二个、第三个…。但是如果我们将jdk自带的排序加以应用就不会显得那么复杂了；

我的想法是这样的：既然Java中排序是按数字->英文->汉字来进行排序的，那我们就把每个汉字打头的字符串前面加上一个该字符串第一个字符的拼音的首字母和一个区分符“&”，再使用jdk提供的排序函数进行排序，这时我们得到的就是我们想要的排序的数组了。然后再遍历数组，将包含&符号的字符串去掉&和第一个英文字母便完成了整个排序了，具体实现代码如下（获取汉字拼音需要引用该jar：pinyin4j-2.5.0.jar）：

/**
* 将字符串数字按首字母先后进行排序 
* 
* Java原生排序为 数字->英文->中文 
* 为了将英文和中文首字母相同的排列到一起 
* 先将字符串首字符为汉字的改为该汉字的首字母加上该字符串 
* 为了以示区分中间再加一个分割符& 
* 然后使用Java原生排序算法 
* 再将包含&字符的字符串中的&和首字母去除从而达到排序目的 
* */ 
public static void main(String[] args)  
 String[] arrays = new String[]  "gyu", "sdf", "zf", "大同", "收到", "地方", "三等分", "的人", "反对高铁", "泛代数", "上的投入", "和国家" ;
 for (int i = 0; i < arrays.length; i++) 
  String str = arrays[i];
  if (str.length() == 0)
  return;
  String alphabet = str.substring(0, 1);
  /*判断首字符是否为中文，如果是中文便将首字符拼音的首字母和&符号加在字符串前面*/
  if (alphabet.matches("[\\\\u4e00-\\\\u9fa5]+")) 
  str = getAlphabet(str) + "&" + str;
  arrays[i] = str;
  
 
 /*设置排序语言环境*/
 Comparator<Object> com = Collator.getInstance(java.util.Locale.CHINA);
 Arrays.sort(arrays, com);
 /*遍历数组，去除标识符&及首字母*/
 for (int i=0;i<arrays.length;i++) 
  String str=arrays[i];
  if(str.contains("&")&&str.indexOf("&")==1)
  arrays[i]=str.split("&")[1];
  
  System.out.println(arrays[i]);
 
 
 public static String getAlphabet(String str) 
 HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
 // 输出拼音全部小写
 defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
 // 不带声调
 defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
 String pinyin = null;
 try 
  pinyin = (String) PinyinHelper.toHanyuPinyinStringArray(str.charAt(0), defaultFormat)[0];
  catch (BadHanyuPinyinOutputFormatCombination e) 
  e.printStackTrace();
 
 return pinyin.substring(0, 1);

这时输出结果为：“大同 的人 地方 反对高铁 泛代数 gyu 和国家 三等分 上的投入 收到 sdf zf”，大家也可以自己尝试自己写排序算法去实现，锻炼一下思维也不无坏处，呵呵。