Java基础之常用集合及排序

来源：互联网发布：ubuntu安装qemu 编辑：程序博客网时间：2024/05/16 06:25

本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！

大家好，今天我们来讲一下常用的集合类，如ArrayList、HashMap、HashSet、LinkedList

同步：即多个线程访问一个实例，如果一个线程对实例进行修改，则实例发生改变

Hashmap：是一个键值对组合，允许多个空值和一个空键的出现，可同步，不安全。

HashMap有两种遍历方法：

// 第一种:Map<Object, Object> map = new HashMap<Object, Object>();for (int i = 0; i < 10000; i++) {map.put(it, i);}Iterator<Entry<Object, Object>> iter = map.entrySet().iterator();long time=System.currentTimeMillis();while (iter.hasNext()) {Entry<Object, Object> entry = iter.next();Object key = entry.getKey();Object val = entry.getValue();}long time2=System.currentTimeMillis();// 第二种:Iterator<Object> iter2 = map.keySet().iterator();while (iter2.hasNext()) {Object key = iter2.next();Object val = map.get(key);}long time3=System.currentTimeMillis();System.out.println("(time3-time2)>(time2-time)："+((time3-time2)>(time2-time)));

运行结果：

(time3-time2)>(time2-time)：false

很显然，第二种方法要比第一种方法快，是一种轻量级的处理方式。

Hashset：不允许有重复元素，不同步，线程安全，可自动排序，与List用法相似。

有关HashSet：

HashSet<Integer> set = new HashSet<Integer>();set.add(2);set.add(1);set.add(4);set.add(2);Iterator<Integer> it = set.iterator();while(it.hasNext()){System.out.println(it.next());}

执行结果：

说明两个问题，第一、HashSet是不允许重复数据的，第二、HashSet是自动排序的

ArrayList：查找数据快，由其数组结构决定，是动态数组而非链表，有下标。底层由数组支持。

LinkedList：增加、删除数据快，而查找数据慢，前一个元素带有后一个元素的索引。底层由双向链表实现。

最有争议的是修改这一块，关于修改，它其实是删除+增加，理论上说是LinkedList要快一点。

ArrayList<Integer> list = new ArrayList<Integer>();for (int i = 0; i < 1000000; i++) {list.add(i);}LinkedList<Integer> list2 = new LinkedList<Integer>();for (int i = 0; i < 1000000; i++) {list2.add(i);}long time4 = System.currentTimeMillis();list.remove(100);list.add(100, 9000);long time5 = System.currentTimeMillis();list2.remove(100);list2.add(100, 9000);long time6 = System.currentTimeMillis();System.out.println("(time6-time5)>(time5-time4)："+ ((time6-time5)>(time5-time4)));}

运行结果：

(time6-time5)>(time5-time4)：false

很显然LinkedList要比ArrayList修改要快。

下面是有关List集合中对象排序的问题：

ArrayList和LinkedList是两个集合类，一般查找数据操作多需要用前者，删除插入操作多的要用后者。

方法一：

主程序：

package test.test5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

//按姓名的长度排序

public class SortByName {

public static void main(String[] args) {
// Student stu1 = new Student(23, "fred");
// Student stu2 = new Student(29, "frankie");
// Student stu3 = new Student(27, "gv");
// Student stu4 = new Student(28, "terry");
Student stu1 = new Student(23, "刘L中");
Student stu2 = new Student(29, "魏W");
Student stu3 = new Student(27, "张");
Student stu4 = new Student(28, "杨Y史泰龙");
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
list.add(stu3);
list.add(stu4);
Collections.sort(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).name + ":" + list.get(i).age);
}
}
}

结果：

张:27
魏W:29
刘L中:23
杨Y史泰龙:28

Bean程序：

package test.test4;

import test.test3.PinYin;

//要实现其Comparable接口
public class Student implements Comparable<Student> {
public int age;
public String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}

//如果需要从小到大的排序，需要用本对象与传过来的对象进行比较

@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
int a = o.name.length();
int b = this.name.length();
return b - a;
}

}

方法二：

package test.test5;

import java.util.Collections;
import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
public static void main(String[] args) {
Vector<String> v = new Vector<String>();
// 把对象加入Vector
v.add("ab");
v.add("ef");
v.add("cd");
v.add("ij");
v.add("gh");
// 排序
Collections.sort(v);// Collections.sort给集合排序，根据元素的自然顺序对指定列表按升序进行排序。
// 输出
Iterator<String> it = v.iterator();// 返回以正确顺序在此列表的元素上进行迭代的迭代器。
while (it.hasNext()) {// 遍历iterator
String t = (String) it.next();// 向下读取一个iterator
System.out.println(t);
}
}
}