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的时候刷新的。