arraylist排序,Java，对两条arraylist（String）排序并插入新元素

arraylist排序,Java，对两条arraylist（String）排序并插入新元素详细介绍

本文目录一览： c#arraylist 怎样排序

可以使用ArrayList的Sort()方法
使用Sort方法，可以对集合中的元素进行排序。Sort有三种重载方法，声明代码如下所示。
public void Sort();
//使用集合元素的比较方式进行排序
public void Sort(IComparer comparer);
//使用自定义比较器进行排序
public void Sort(int index, int count, IComparer comparer)
//使用自定义比较器进行指定范围的排序

注意：为使用Sort方法进行排序，集合中的所有元素必须实现IComparable接口，否则，将抛出异常。

如何实现对ArrayList排序 sort

现在java8帮你封装了一把，可以不用Colltion的sort方法啦，很简单 list.stream.sorted(); 就可以直接排序啦，对于基本类型的数据 若是一个对象的集合，比如List list这类的集合
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test {
public static void main(String[] args) {
Student zlj = new Student("丁晓宇", 21);
Student dxy = new Student("赵四", 22);
Student cjc = new Student("张三", 11);
Student lgc = new Student("刘武", 19);
List

studentList = new ArrayList

();

studentList.add(zlj);

studentList.add(dxy);

studentList.add(cjc);

studentList.add(lgc);

System.out.println("按年龄升序：");

Collections.sort(studentList, new SortByAge());

for (Student student : studentList) {

System.out.println(student.getName() + " / " + student.getAge());

}

System.out.println();

System.out.println("按姓名排序：");

Collections.sort(studentList, new SortByName());

for (Student student : studentList) {

System.out.println(student.getName() + " / " + student.getAge());

}

}

}

class SortByAge implements Comparator {

public int compare(Object o1, Object o2) {

Student s1 = (Student) o1;

Student s2 = (Student) o2;

return s1.getAge().compareTo(s2.getAge());

// if (s1.getAge() > s2.getAge())

// return 1;

// return -1;

}

}

class SortByName implements Comparator {

public int compare(Object o1, Object o2) {

Student s1 = (Student) o1;

Student s2 = (Student) o2;

return s1.getName().compareTo(s2.getName());

}

}

输出结果：

按年龄升序：

张三 / 11

刘武 / 19

丁晓宇 / 21

赵四 / 22

按姓名排序：

丁晓宇 / 21

刘武 / 19

张三 / 11

赵四 / 22

java arraylist 按照对象的属性排序

修改你的
student
class，添加
comparable
接口，重写
compareto
方法。然后你可以用
treeset
结构进行排序。它会自动排序。
建议你用Map，然后0=sunday,1=monday...再通过comparator
用TreeMap排序；或者你继承
Comparable
重写compareTo方法
List中的元素是对象的话，若要按该List中元素的某个属性进行排序，那么应该重写里面元素的hashCode和equals方法，然后再排序。比如该问题要重写course的hashCode和equals方法

使用ASP.NET?ArrayList对象创建数组和排序的示例

　　ASP.NET中的ArrayList对象是一个由包含单一数据值的数据项组成的集合。如何创建ArrayList对象以及如何对ArrayList内的各数据项内容进行排序呢，下面说一些代码示例。
　　创建ArrayList数据项是用Add()方法添加到ArrayList的。以下代码创建一个新的ArrayList对象，命名为mycountries，并加入4个数据项：
　　还可以用Sort()方法为ArrayList按字母顺序或数字顺序排序：
　还可以用Sort()方法为ArrayList按字母顺序或数字顺序排序：
　　要想按倒序排序，可在Sort()方法的后面使用Reverse()方法：
　　你可以试着将代码复制到你的ASP.NET页面中测试看效果。

如何对ArrayList中的某个属性进行排序

这个结果是降序的，升序的话条件换下
Collections.sort(list, new Comparator
<map
>() {

@Override

public int compare(Map

o1, Map

o2) {

// TODO Auto-generated method stub

int time1 = (Integer) o1.get("RemindTime");

int time2 = (Integer) o2.get("RemindTime");

if (time1 > time2) {

return -1;

} else if (time1 == time2) {

return 0;

} else {

return 1;

}

}

});

</map

Java，对两条arraylist（String）排序并插入新元素

是这样的，我觉得你可以换个思路，我们首先只取出b,a,d 构成链表listA= (b,a,d)，然后对listA进行排序，listA排序完成后，顺序取出listA中的值为key，取出map中的数据放到listB中，这样顺序肯定是一致的，也就变相的完成排序工作了
代码就不写了，排序的话简单来说就是一个map遍历的问题，
插入的话可以这样，因为第一个表和第二个表已经对应上，那么先插入到listA中，然后获取到插入的位置Index，根据位置插入到B中，
Arralist和linkedlist的方法接口差不多，建议你下载一个中文的JDK API资料，里面很详细
linkedlist：
public void add(int index,
E element)
在此列表中指定的位置插入指定的元素。移动当前在该位置处的元素（如果有），所有后续元素都向右移（在其索引中添加 1）。
Arralist：
public void add(int index,
E element)
将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

java 怎么将List里面数据排序

不好意思，上午只是粗略地看了一下，没有细致看，现在详细回答你的提问。
ArrayList底层是用一个长度为10的Object数组实现，不管添加进去什么类型的数据，都会转换成Object对象，除非你用很早以前的JDK版本。这样就好理解了，像你写的程序arrayList1中add了String和Integer两种类型的数据，这两类对象没有什么可比性，就像拿打火机和U盘比一个性质。所以，是没有办法进行直接排序的。
你要求的是要按ArrayList里面的第1、2、4数据进行排序，这个可以。
先来arrayList1
四个数据分别是2、"daas"、6、"1"，第1、2、4数据即2、“daas”、“1”，我选择按照String类型进行排序，所以第1个数据2转换成String类型即可。因为第3个数据6不进行排序，remove就好。这是个题还是个什么，其实还是留了点活路的，因为后面的（你arrayList2\3\4下面）代码都是往arrayList1中添加的，而且还都是String类型。这也是我选择String类型进行排序的原因。代码如下：
List arrayList1 = new ArrayList();
arrayList1.add(2); //0
arrayList1.add("daas"); //1
arrayList1.add(6); //2
arrayList1.add("1"); //3
list.add(arrayList1);

//my code
String convert = String.valueOf(arrayList1.get(0));
arrayList1.remove(2);
arrayList1.remove(0);
arrayList1.add(convert);

/此处为你的arrayList2\3\4代码

Collections.sort(arrayList1);
for(int i = 0; i < arrayList1.size(); i++) {
System.out.println(arrayList1.get(i));
}
结果为：
1
2
3
5
8
daas
因为怕你深挖，强调两点：
第一点，由结果看出Collections.sort(arrayList1)，是以String的ASCII码进行排序的，为了证明这一点，就要看原代码，这时你就会发现JDK中String的compareTo方法是个空实现，底层并不是用java写的，这点没事，我们可以用一定的方法让它把特征暴露出来，然后就可以理解思想。你看我下面写的小测试程序就会明白。
String a = new String("Z");
String b = new String("A");
System.out.println(a.compareTo(b));

String c = new String("A");
String d = new String("B");
System.out.println(c.compareTo(d));

//看结果，证明String的自然顺序比较即比较ASCII值，只是第一步。
//看结果，证明compareTo返回值是后面的ASCII码减支前面的ASCII码，第二步。

String e = new String("g");
String f = new String("e");
String h = new String("h");
List

list = new ArrayList

();

list.add(e);

list.add(f);

list.add(h);

Collections.sort(list);

for(String i : list) {

System.out.println(i);

}

结果为：

25

-1

e

g

h

//证明String的自然排序即ASCII码从小到大排序，最后一步。

第二点，你的要求是“要按ArrayList里面的第1、2.4数据进行排序，分别怎么做啊”，这个问题的描述有问题，或者不详细，arryList2、arrayList3、arrayList4任何一个里面一共就add了3个数据，哪来第4个。如果是分别对arrayList2\3\4里面的数据进行排序，两个选择，（1）把所有Integer转换成String类型，再排序，参考arrayList2。（2）运用Integer.valueOf()方法，将内容为数字的String数据转换成Integer，把原来的remove掉，把内容非数字的String数据remove掉，再排序，桶排序、冒泡排序、快速排序等你随便选。

讲解到这，不管想对哪个list进行排序，你应该都会写了。

总结：

除非比较ASCII码，Integer类型和内容为非数字的String类型数据是没有办法进行比较的，不管是直接比较，还是间接比较。还是上面那句话，像打火机和U盘没有可比性一样，理解这点很重要。

即使用Integer.valueOf()方法对内容为非数字的String类型数据进行转换没有用，会报NumberFormatException。说这点意思是如果你想按Integer类型排序，得把所有内容为非数字的String类型数据remove掉。

题外话：这种类型的题我记得上大学的时候有，不知道你是不是学生，今天想来，其实用处真不大，都用泛型，现在写代码不用泛型的程序员几乎是完全不存在了。

祝心情愉快~~

亲手打，如果满意，把分给我吧~~哈哈。。

java 中有城市类 存在arraylist 怎么让它按名字首字母排序

参考代码如下
import java.util.ArrayList;import java.util.Comparator;public class ListDemo { public static void main(String[] args) { ArrayList

city = new ArrayList

(); city.add("Jonesboro"); city.add("Chaohu"); city.add("LittleRock"); city.add("bridgeport"); city.add("Rome"); city.add("chicago"); System.out.println("排序前"+city); //排序. city.sort(new Comparator

() { //重点是这个函数 public int compare(String o1, String o2) { //忽略掉大小写后,进行字符串的比较 String s1 = o1.toLowerCase(); String s2 = o2.toLowerCase(); return s1.compareTo(s2);//从a-z的排 //return s2.compareTo(s1);//从z-a的排 } }); System.out.println("排序后"+city); }}运行效果

排序前[Jonesboro, Chaohu, LittleRock, bridgeport, Rome, chicago]排序后[bridgeport, Chaohu, chicago, Jonesboro, LittleRock, Rome]

Java中的ArrayList怎么进行冒泡排序

temp=hxr; //就是这里我不懂啊 引用类型的只是调用引用 这样编写会覆盖掉hxr
al.set(i, hxr1);
al.set(j, temp);
这段代码是利用中间变量temp把hxr和hxr1交换位置。
解释：
①hxr的初始位置在i，hxr1的初始位置在j
②先把hxr保存在中间变量temp中，
③再把hxr1放在位置i上，
④最后把hxr放在位置j上。
如果没有第②步的话，做第③步时hxr1对象就会把hxr对象覆盖了。
补充说明：
关于你说的这个：引用类型的只是调用引用 这样编写会覆盖掉hxr
你在Eclipse里面单步调试一下就知道了。
做完第③步后，hxr1并没有把temp和hxr覆盖了。
这样看的话，没有中间变量temp也能完成交换。
出现这样的状况是因为java的引用类型是介于指针和引用之间的一个东西.
你把temp=hxr;去掉，并在al.set(i, hxr1);之前加上hxr.tickets = 2之类的话改变hxr的值，这是你再看看hxr的值与List al中第i个的值，再往下执行，好好观察每个变量的数值变换情况。
仔细体会一下，很快就会明白了！
楼上的真倒,虽然算法是一样的,但是人问的是JAVA中ArrayList对象的冒泡排序,你却搞个C的出来,好歹也改下啊.
---------------------------------------------------------
//main()方法自己写吧,为了方便,假定ArrayList存放的是Integer对象
//另外,代码是给你写了!但是希望以后不要看到你再上来让人帮你写代码了,把自己写的代码贴上来让人帮你改倒还可取.
public class Sort {
public static void bubbleSort(List list)
{
int size = list.size;
Integer[] arr = (Integer[])list.toArray();//你的类实现Comparable接口后,这里的类型换下就是了.
Integer iTmp;
for (int i = 1; i < size; i++)
{
boolean flag = false;
for (int j = size - 1; j >= i; j--)
{
if (arr[j].compareTo(arr[j - 1]) > 0)
{
iTmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = iTmp;
flag = true;
}
}
if (!flag) return;
}
}
}
===================================
问题补充的回复:
让你的类实现Comparable接口即可.
Arrays和Collections里的sort方法都没有用冒泡排序的,因为冒泡排序效率实在太低了.只能用来作算法演示而已,实际应用中不会用到它的.
#include

#include

#define TURE 1

#define FLASE 0

void BubbleSort(int a[],int n)

{

int i,j;

int change;

int temp;

for(i=n-1,change=TURE;i>=1&&change;i--)

{

change=FLASE;

for(j=1;j<=i;j++)

if(a[j]>a[j+1])

{

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

change=TURE;

}

}

}

void Print(int a[],int n)

{

int i;

for(i=1;i<=n;i++)

printf(" a[%d]=%d",i,a[i]);

}

main()

{

int a[100];

int i,n;

printf("\nInput the Length:\n");

scanf("%d",&n);

printf("\nInput the number:\n");

for(i=1;i<=n;i++)

scanf("%d",&a[i]);

printf("\nBefore:\n");

Print(a,n);

BubbleSort(a,n);

printf("\nAfter:\n");

Print(a,n);

getch();

printf("Press any key to continue...");

clrscr();

}

记得arraylist里面有个sort方法，就可以进行排序了，为啥还要用冒泡呢！？如果真的要做冒泡的话，你用下标来取值进行比较咯

纠正一下，Soft()不在arraylist，应该在collections里

java中的ArrayList进行冒泡排序，主要是循环遍历取出数据，然后进行比较排序，如下代码：

package com.qiu.lin.he;import java.util.ArrayList;public class Ceshi { public static void main(String[] args) { ArrayList

list = new ArrayList

(); list.add(76); list.add(4); list.add(786); list.add(43); list.add(21); list.add(432); list.add(10); for (int i = 0; i < list.size() - 1; i++) { for (int j = 1; j < list.size() - i; j++) { Integer a; if (list.get(j - 1).compareTo(list.get(j)) > 0) { // 比较两个整数的大小 a = list.get(j - 1); list.set((j - 1), list.get(j)); list.set(j, a);//交换数据 } } } for (Integer s : list) { System.out.println(s.intValue());//输出arraylist的数据 } }}运行结果如下：

arrayList和linkedList在排序上的区别

arrayList底层是数组，增删慢，查找快
linkedList底层是双向链表，增删快，查找慢
而排序看谁快的话要具体看用什么排序方法。
http://www.cnblogs.com/zjss/p/5232048.html
ArrayList和LinkedList都实现了List接口，ArrayList的实现用的是数组，LinkedList是基于链表，ArrayList适合查找，LinkedList适合增删。
ArrayList与LinkList两者的区别：
ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。
相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。
LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
但是要删除数据却是开销很大的，因为这需要重排数组中的所有数据。
2) 相对于 ArrayList ， LinkedList 插入是更快的。因为 LinkedList 不像 ArrayList 一样，不需要改变数组的大小，也不需要在数组装满的时候要将所有的数据重新装入一个新的数组，这是 ArrayList 最坏的一种情况，时间复杂度是 O(n) ，而 LinkedList 中插入或删除的时间复杂度仅为 O(1) 。 ArrayList 在插入数据时还需要更新索引（除了插入数组的尾部）。
3) 类似于插入数据，删除数据时， LinkedList 也优于 ArrayList 。
4) LinkedList 需要更多的内存，因为 ArrayList 的每个索引的位置是实际的数据，而 LinkedList 中的每个节点中存储的是实际的数据和前后节点的位置 ( 一个 LinkedList 实例存储了两个值： Node

first 和 Node

last 分别表示链表的其实节点和尾节点，每个 Node 实例存储了三个值： E item,Node next,Node pre) 。

什么场景下更适宜使用 LinkedList，而不用ArrayList

1) 你的应用不会随机访问数据 。因为如果你需要LinkedList中的第n个元素的时候，你需要从第一个元素顺序数到第n个数据，然后读取数据。

2) 你的应用更多的插入和删除元素，更少的读取数据 。因为插入和删除元素不涉及重排数据，所以它要比ArrayList要快。