java數組排列
❶ java怎麼讓數組的數字從大到小排序
將數字從大到小排序的方法：
例如簡一點的冒泡排序，將第一個數字和後面的數字逐個比較大小，如果小於，則互換位置，大於則不動。此時，第一個數為數組中的最大數。然後再將第二個數與後面的數逐個比較，以次類推。
示例代碼如下：
publicclassTest{
publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //兩個數交換位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}
數組對於每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。
Java 語言中提供的數組是用來存儲固定大小的同類型元素。
你可以聲明一個數組變數，如 numbers[100] 來代替直接聲明 100 個獨立變數 number0，number1，....，number99
(1)java數組排列擴展閱讀
Java中利用數組進行數字排序一般有4種方法：
1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。
2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。
3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。
4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。
❷ java中如何對數組和集合進行排序
java中對集合排序，可以使用Collections.sort來進行排序，可以對中文、字母、數字進行排序，當比較的是對象時候，讓該類實現comparable介面，示例如下：
Collections.sort(dataMap, new Comparator<Map<String, Object>>() { //排序介面實現方法 @Override public int compare(Map<String, Object> lhs, Map<String, Object> rhs) { switch (whichsort) { case System_OpenPosition_Sort_Currency: String d2 = ((String) rhs.get(Instrument)); String d1 = (String) lhs.get(Instrument); if (d2 != null && d1 != null) { int flag = d1.compareTo(d2); if (flag == 0) { Double d3 = ((Double) rhs.get(OpenPrice)); Double d4 = (Double) lhs.get(OpenPrice); if (d3 != null && d4 != null) { int flag2 = d4.compareTo(d3); if (flag2 == 0) { String d5 = ((String) rhs.get(BuySell)); String d6 = (String) lhs.get(BuySell);//文字排序 if (d5 != null && d6 != null) { return d6.compareTo(d5);//返回一個int類型，用來判斷是否大於、小於還是等於 } } return d4.compareTo(d3); } } else { return flag; } // return d1.compareTo(d2); }
❸ java 數組排序的方法
Arrays.sort()是按升序對數組進行排序的，當然會是矮的在前面了。
❹ Java通過幾種經典的演算法來實現數組排序
JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。
快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。
冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。
選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。
插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。
<1>利用Arrays帶有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //進行排序 for(int i: a){ System.out.print(i); } } }
<2>冒泡排序演算法
public static int[] bubbleSort(int[] args){//冒泡排序演算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
<3>選擇排序演算法
public static int[] selectSort(int[] args){//選擇排序演算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
<4>插入排序演算法
public static int[] insertSort(int[] args){//插入排序演算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
❺ Java數組排序
幫你改了一下，希望能幫助你。不知道你那個sort怎麼來的，從新寫了個。
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class ArrayTest {
public static void main(String[] args)
{
int[] num=new int[]{5,2,3};
sort(num);
for(int i=0;i<num.length;i++)
{
System.out.println(num[i]);
}
}
public static void sort(int[] num){
Set Arrays = new TreeSet();
for(int i=0;i<num.length;i++){
Arrays.add(String.valueOf(num[i]));
}
Iterator it = Arrays.iterator();
int i=0;
while(it.hasNext()){
num[i] =Integer.parseInt((String)it.next());
i++;
}
}
}
class Point
{
int x,y;
Point(int x,int y)
{
this.x=x;
this.y=y;
}
}
❻ java數組如何排序
如果是升序可以使用 Arrays.sort（數組名)（注意：要使用這個方法必須導入java.util.Arrays包）或者使用冒泡排序，如果是降序只能自己寫，推薦使用冒泡排序
❼ java數組排序
Java API針對集合類型排序提供了兩種支持：
java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)
第一個方法要求所排序的元素類必須實現java.lang.Comparable介面。
第二個方法要求實現一個java.util.Comparator介面。
java.lang.Comparable介面和java.util.Comparator介面是Java對排序最提供最基本支持。這兩個介面不但可以用於集合元素排序，還可以用於數組排序。
如果數組或集合元素是String類型，則可以利用Java API實現的Comparator<String>對象String.CASE_INSENSITIVE_ORDER為容器元素排序。
下面給出兩個里測試，涵蓋集合和數組的排序，並且還演示了數組和集合的相互轉換，附件裡面是完整的排序演示代碼。
方法一：實現Comparable介面排序package collsort.comparable;
package com.cvicse.sort.comparable;
public class Cat implements Comparable<Cat> {
private int age;
private String name;
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
public int compareTo(Cat o) {
return this.getAge() - o.getAge();
}
......
} 通過實現Comparable介面實現個性化排序測試。排序測試，Collection.sort(list)升序排列Collections.sort(list, Collections.reverseOrder());降序排列；Collections.reverse(list);反轉排序，先輸出列表最後一個元素
public class TestComparable {
public static void main(String args[]) {
test();
test2();
}
public static void test() {
......
List<Cat> listCat1 = new ArrayList<Cat>();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat1.add(cat1);
listCat1.add(cat2);
listCat1.add(cat3);
......
System.out.println("調用Collections.sort(List<T> list)listCat2升序排序：");
Collections.sort(listCat1);
System.out.println("降序排列元素:");
Collections.sort(listCat1, Collections.reverseOrder());
System.out.println("Collections.reverse 從列表中最後一個元素開始輸出:");
Collections.reverse(listCat1);
......
}
/**
* 針對數組的排序
*/
public static void test2() {
String[] strArray = new String[] { "z", "a", "C" };
System.out.println("數組轉換為列表");
List<String> list = Arrays.asList(strArray);
System.out.println("順序排序列表");
Collections.sort(list);
System.out
.println("按String實現的Comparator對象String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println("倒序排序列表");
Collections.sort(list, Collections.reverseOrder());
......
}
}方法二：實現Comparator介面排序
public class Person {
private int age;
private String name;
......
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
} 實現了Comparator介面，重寫了compare方法
import java.util.Comparator;
public class PersonComparator implements Comparator<Person> {
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
} 測試方法
public class TestComparator {
public static void main(String args[]) {
test1();
}
public static void test1() {
System.out.println("升序排序測試:");
List<Person> listPerson = new ArrayList<Person>();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator<Person> ascComparator = new PersonComparator();
System.out.println("排序後集合為:");
// 利用Collections類靜態工具方法對集合List進行排序
Collections.sort(listPerson, ascComparator);
System.out.println("\n降序排序測試:");
// 從升序排序對象產生一個反轉(降序)的排序對象
Comparator<Person> descComparator = Collections
.reverseOrder(ascComparator);
System.out.println("利用反轉後的排序介面對象對集合List排序並輸出:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
}
} 以上的例子中使用是對int類型的屬性排序，對String屬性排序可以用以下的方法
public int compareTo(Cat o) {return this.getName().compareTo(o.getName());}comparetTo()函數的使用說明：
如果 結果
<0 a<b
==0 a==b
>=0 a>b
Java如何通過所實現介面的方法進行排序是API內部的事情，Java這樣處理排序目的就是對容器元素排序有一個統一的方式，以簡化編程。
給個例子你自己看吧
❽ 如何用java實現一個數組的排列
首先根據數組的類型不同排序方式也是不同的，如果是基本類型數組，那麼使用冒泡或者其他排序方式都是很簡單的，例如：http://blog.csdn.net/yyywyr/article/details/8075433。如果不想自己寫排序演算法那麼使用Arrays.sort()進行排序也是不錯的。
如果是自定義類型的數組，推薦使用java自帶的工具類：Comparable介面，並重寫CompareTo()方法。或者Compartor。