android數組排序
1. android sqlite 刪除後怎麼該變主鍵把數據重新排序
你是指刪除某一項後ID不連續的問題么？如果是指這個一般的做法是不會對數據項進行重新排ID的，而是通過一個數組來對應各個數據項~對一個數據表進行排序會耗費很大的資源和時間~任何情況下都不推薦~
2. Android數組字元串怎麼排序
字元串排序的話，你可以實現一個compartor介面，然後進行排序即可，參考一下網上的例子
3. Android中怎麼排序日期和時間
時間排序，方法很多，以下提供幾種常用的方法。
轉化成long類型進行對比。
通過Collections.sort（）方法進行排序。
【原理】
主要是通過把時間轉化成一些可以對比的數據類型進行排序對比。
【詳細方式或原理】
轉化成long類型進行對比
轉化代碼：
java">StringsDt="08/31/200621:08:00";
SimpleDateFormatsdf=newSimpleDateFormat("MM/dd/yyyyHH:mm:ss");
Datedt2=sdf.parse(sDt);
//繼續轉換得到秒數的long型
longlTime=dt2.getTime()/1000;
把需要對比的時間轉化成long類型進行對比。
2.通過Collections.sort（）方法進行排序
Collections.sort（）是java提供的官方排序方式。適合多類型排序。
詳細的對比代碼如下：
一般情況下要重寫下Comparator 介面。
importjava.util.Comparator;
{
@Override
publicintcompare(Objectlhs,Objectrhs){
//時間對比
numa=(num)lhs;
numb=(num)rhs;
return(b.getCount()-a.getCount());
}
}
然後在排序的地方進行使用
Comparatorcomp=newSortComparator();
Collections.sort(list,comp);
【最後】
如果數據類型復雜推薦使用方法二，如果類型簡單推薦使用方法一。
4. 學習android開發，需要學習java的gui和資料庫oracle資料庫嗎
不怎麼需要。。
Android開發中的UI是一套全新的東西，有自己的MVC架構，和JAVA中的GUI（AWT，SWING）不同，但如果會JAVA的GUI開發的話還是不錯的，因為兩者之中的一些機制還是有些類似的，如事件監聽器模型，其它關聯不是很大，可以相互借鑒。
至於資料庫，Android系統內置了SQLite資料庫，支持的數據類型和函數和Oracle簡直不可同日而語，畢竟，一個是專用於嵌入式的資料庫，一個是企業級大型資料庫，這個完全不用去學Oracle。SQLite資料庫的使用很簡單的，藉助於Android中的資料庫操作封閉類，可以很容易的設計出功能強大的資料庫軟體的。
5. Android數組字元串怎麼排序
Comparator cmp = Collator.getInstance(java.util.Locale.CHINA); String[] arr = { "張三", "李四", "王五", "劉六" }; Arrays.sort(arr, cmp);
6. Android 如何按時間先後顯示ListView數據
解決方法：
lisrview綁定的是哪種adapter？我假設是最簡單的arrayAdapter，其實原理都一樣。
綁定adapter的數據大多數是數組。
數組的排序總會把？我記得是sort。
排序好再將數據綁定到adapter，然後adapter綁定到listview
7. android 數組添加數據
追加一個 數 之後再 執行一下 排序 就可以了 參考 排序 方法 ArrayList arr=new ArrayList(); int Temp;arr.Add(..).... for(int i=0;i<N;i++) { for(int j=0;j<N-i-1;j++) { if(int.Parse(arr[j+1])<int.Parse(arr[j])) { Temp=int.Parse(arr[j+1]); arr[j+1]=int.Parse(arr[j]); arr[j]=Temp; } } }
8. Android開發中ArrayMap與HashMap有哪些不同
1、存儲方式不同
HashMap內部有一個HashMapEntry<K, V>[]對象，每一個鍵值對都存儲在這個對象里，當使用put方法添加鍵值對時，就會new一個HashMapEntry對象，具體實現如下：
[java] view plain
@Override public V put(K key, V value) {
if (key == null) {
return putValueForNullKey(value);
}
int hash = secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
//先查找有沒有對應的key值，如果有，就改寫value，並返回改寫前的value值：oldValue
for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
preModify(e);
V oldValue = e.value;
e.value = value;
return oldValue;
}
}
// No entry for (non-null) key is present; create one
modCount++;
if (size++ > threshold) {
//擴容，雙倍
tab = doubleCapacity();
index = hash & (tab.length - 1);
}
addNewEntry(key, value, hash, index);
return null;
}
//創建對象存儲鍵值對
void addNewEntry(K key, V value, int hash, int index) {
table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}
ArrayMap的存儲中沒有Entry這個東西，他是由兩個數組來維護的
[java] view plain
int[] mHashes;
Object[] mArray;
mHashes數組中保存的是每一項的HashCode值，mArray中就是鍵值對，每兩個元素代表一個鍵值對，前面保存key，後面的保存value，我們看看下面代碼的結果：
[java] view plain
arraymap = new HashMap<String, String>();
a.put("a", "a_value");
a.put("b", "b_value");
執行上面代碼後，arraymap中的存儲是這樣的
是不是能清楚地看到ArrayMap的存儲了，這種存儲在put代碼中如下：
[java] view plain
mHashes[index] = hash;
mArray[index<<1] = key;
mArray[(index<<1)+1] = value;
2、添加數據時擴容時的處理不一樣
先來看看HashMap
[java] view plain
if (size++ > threshold) {
tab = doubleCapacity();
index = hash & (tab.length - 1);
}
doubleCapacity進行雙倍擴容，它的代碼中有這么一句話
[java] view plain
HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
最終，這個newTable將作為擴容後的新對象返回，那麼makeTable做了什麼呢，如下：
[java] view plain
private HashMapEntry<K, V>[] makeTable(int newCapacity) {
@SuppressWarnings("unchecked") HashMapEntry<K, V>[] newTable
= (HashMapEntry<K, V>[]) new HashMapEntry[newCapacity];
table = newTable;
threshold = (newCapacity >> 1) + (newCapacity >> 2); // 3/4 capacity
return newTable;
}
我們清楚地看到，這里進行了new操作，重新創建對象，開銷很大。
那麼ArrayMap呢，看看：
[java] view plain
//如果容量不夠
ize >= mHashes.length) {
final int n = mSize >= (BASE_SIZE*2) ? (mSize+(mSize>>1))
: (mSize >= BASE_SIZE ? (BASE_SIZE*2) : BASE_SIZE);
if (DEBUG) Log.d(TAG, "put: grow from " + mHashes.length + " to " + n);
final int[] ohashes = mHashes;
final Object[] oarray = mArray;
//分配數組
allocArrays(n);
if (mHashes.length > 0) {
if (DEBUG) Log.d(TAG, "put: 0-" + mSize + " to 0");
//特別注意這，是，而不是new，效率提升
System.array(ohashes, 0, mHashes, 0, ohashes.length);
System.array(oarray, 0, mArray, 0, oarray.length);
}
//釋放無用空間，收縮數組
freeArrays(ohashes, oarray, mSize);
}
ArrayMap用的是數據，所以效率相對要高。
3、ArrayMap提供了數組收縮的功能，在clear或remove後，會重新收縮數組，是否空間
4、ArrayMap採用二分法查找；
以上就是android開發中，HashMap與ArrayMap的區別，大家在涉及到內存方面的實現，可根據實際情況選擇這兩種不同的方式。
9. android 數組裡面數據有name date 怎麼賦值到model裡面去
java之數組
數組概述：
1、數組可以看成是多個相同數據類型數據的組合，對這些數據的統一管理。
2、數組變數屬引用類型，數組也可以看成是對象，數組中的每個元素相當於該對象的成員變數。
3、數組中的元素可以是任何類型，包括基本類型和引用類型。
一維數組的聲明：
1、一維數組的聲明方式：
type var[]; 或type[] var;
例如:
int a1[]; int[] a2; double b[]; Person[] p1; String s1[];
2、java語言中聲明數組時不能指定其長度（數組中元素的個數），例如：
int a[5];//非法
數組對象的創建：
1、java中使用關鍵字new 創建數組對象，格式為：
數組名 = new 數組元素類型[數組元素個數]；
例如：
public class TestArray{
public static void main(String args[]){
int[] arr;
arr = new int[5];
for(int i=0;i<5;i++){
arr[i] = i;
System.out.println(arr[i]);
}
}
}
2、元素為引用類型的數據（注意：元素為引用數據類型的數組中的每一個元素都需要實例化）
例如：
public class TestArray{
public static void main(String args[]){
Date[] date;
date = new Date[3];
for(int i=0; i<3; i++){
date[i] = new Date(2014,10,25);
System.out.println(date[i].year+"年，"+date[i].month+"月，"+date[i].day+"日！");
}
}
}
class Date{
int year,month,day;
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
數組初始化：
1、動態初始化：
數組定義與為數組元素分配空間和賦值的操作分開進行，例如：
public class TestArray{
public static void main(String args[]){
int[] arr = new int[3]; //數組定義
arr[0]=1; //數組初始化
arr[1]=2;
arr[2]=3;
Date[] date = new Date[3]; //數組定義
date[0] = new Date(2014,10,25); //數組初始化
date[1] = new Date(2014,10,25);
date[2] = new Date(2014,10,25);
}
}
class Date{
int year,month,day;
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
2、靜態初始化
在定義數組的同時就為數組元素分配空間並賦值，例如：
public class TestArray{
public static void main(String args[]){
int a[] = {1,2,3};
Date[] date = {new Date(2014,10,25), new Date(2014,10,26), new Date(2014,10,27)};
}
}
class Date{
int year,month,day;
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
3、數組元素的默認初始化：
數組時引用類型，它的元素相當於類的成員變數，因此數組分配空間後，每個元素也被按照成員變數的規則被隱式初始化，例如：
public class TestArray{
public static void main(String args[]){
int[] a = new int[3];
Date[] date = new Date[3];
System.out.println(a[2]);
System.out.println(date[2]);
}
}
class Date{
int year,month,day;
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
}
數組元素的引用：
1、定義並用運算符new為之分配空間後，才可以引用數組中的每個元素，數組元素的引用方式為：
①、arrayName[index]
index為數組元素下標，可以使整形常亮或整形表達式。如：
a[3], b[i], c[6*i];
②、數組元素的下標從0開始；長度為n的數組的合法下標取值范圍為：
0~n-1;
2、每個數組都有一個屬性lendth（註：這里length是一個屬性，不是方法，沒有加括弧（），我們這里特別說明是為了和String的length()方法做區別）指明他的長度，例如：
a.length的值為數組a的長度（元素個數）
註：
public static void main(String args[]){}
我們每個類中的主函數也有一個數組，名叫srgs,那麼這個數組時幹嘛用的呢？這個數組就好比，我們在命令行中注入 ipconfig -all 中的all. 我們可以在輸入 java TestArray(類名) 23,12，aa,bbb 這個跟幾個參數。然後可以在代碼中輸出來看到。
注（基礎類型的包裝類）：
基礎類型的包轉類， 基礎類型是分配在棧內存中的 ， 包裝類是分配在堆空間裡面的 。
基礎類型的包裝類有：Boolean---boolean 、 Byte---byte 、 Character---char 、 Double---double 、 Float---float 、 Integer---int 、 Long--- long 、 Short---short 通常我們使用parsexxx()方法來將string類型轉換為我們想要的數據類型。我們也可以使用string類型的valueOf()方法將想要的 數據類型轉換為string類型。
下面我們舉一個args[]參數和基礎類型包裝類一起使用的例子，用來計算+-x/：
public class TestArgs{
public static void main(String args[]){
if(args.length<3){
System.out.println("error~~~");
System.exit(0);
}
double b1 = Double.parseDouble(args[0]);
double b2 = Double.parseDouble(args[2]);
double b = 0;
if(args[1].equals("+")){
b = b1 + b2;
}else if(args[1].equals("-")){
b = b1-b2;
}else if(args[1].equals("x")){
b = b1*b2;
}else if(args[1].equals("/")){
b = b1/b2;
}else{
System.out.println("error operation!!!");
}
System.out.println(b);
}
}
下面舉一個用ars輸入10個數，並且用選擇排序，從小到大排序的示例：
public class TestSortInt{
public static void main(String args[]){
int[] a = new int[args.length];
for(int i=0; i<args.length; i++){
a[i] = Integer.parseInt(args[i]);
}
int k,temp;
for(int i=0; i<a.length; i++){
k = i;
for(int j=i+1; j<a.length; j++){
if(a[k]>a[j]){
k=j;
}
}
if(k!=i){
temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
for(int i=0; i<a.length; i++){
System.out.print(a[i] + " ");
}
}
}
下面我們用數組裡面裝一個日期類型做排序的示例，用了冒泡排序。
public class TestDateSort{
public static void main(String args[]){
Date[] date = new Date[5];
date[0] = new Date(2006,5,4);
date[1] = new Date(2006,7,4);
date[2] = new Date(2008,5,4);
date[3] = new Date(2004,5,9);
date[4] = new Date(2006,5,4);
bubbleSort(date);
for(int i=0; i < date.length; i++){
System.out.println(date[i]);
}
}
public static Date[] bubbleSort(Date[] a){
int len = a.length;
for(int i=len; i>=1; i--){
for(int j=0; j<i-1; j++){
if(a[j].compare(a[j+1])>0){
Date temp = a[j+1];
a[j+1] = a[j];
a[j] = temp;
}
}
}
return a;
}
}
class Date{
private int year,month,day;
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public int compare(Date date){
return year>date.year?1
:year<date.year?-1
:month>date.month?1
:month<date.month?-1
:day>date.day?1
:day<date.day?-1
:0;
}
public String toString(){
return "year,month,day ---- " +year+" - "+month+" - "+day;
}
}
10. 關於android兩泛型ArrayList的對比，按某值大到小輸出
A 和B實現Comparable介面
public class A implements Comparable<A>
{
@Override
public int compareTo(A anotherA)
{
return Y - anotherA.Y;
}
}
這樣就可以調用排序了
paint()一般是你調用invalidate的時候刷新的。