有序集合
Vector集合
jdk1.0版本 线程安全 效率低
Vector<String> vs = new Vector<String>();
vs.add("张三");
vs.add("李四");
vs.add(0, "王五");
for(String s : vs) {
System.out.print(s+" ");
}
System.out.println();
Iterator<String> it = vs.iterator();
while(it.hasNext()) {
System.out.print(it.next()+" ");
}
System.out.println();
Enumeration<String> es = vs.elements();
while(es.hasMoreElements()) {
System.out.print(es.nextElement()+" ");
}
ArrayList
特点:数据模型为数组结构 增删慢 查询快
1.已存满的情况下 会自动扩容 会产生垃圾数据
2.插入新数据 需要移动后续元素
private static final int DEFAULT_CAPACITY = 10; //空参构造集合时产生的数组默认长度
transient Object[] elementData; //初始数组
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //可扩容到最大元素数量
private void grow(int minCapacity) //扩容方法
每次扩容若无指定 则增长原来的1.5倍
构造方法
public ArrayList() 空参构造
public ArrayList(int initialCapacity) 参数为设定的初始元素个数
public ArrayList(Collection<? extends E> c) 传入一个单列集合对象 转为ArrayList集合存储
其他方法
void add(int index) 向参数下标位插入新元素
E get(int index) 获取参数下标位的元素对象
int indexOf(Object) 通过参数对象 找到集合中的下标
E remove(int index) 删除参数下标位元素
E set(int index, newE) 使用参数2 覆盖参数1对应元素
ListIterator listIterator() 获取双向迭代器 默认指针在最左侧
ListIterator listIterator(int) 获取双向迭代器 默认指针在参数位 访问不到参数位
T[] toArray(T[] t) 将当前集合 转存到参数位已声明好的同类型数组中
Object[] o = as.toArray();//由集合而来的新数组
String[] array = new String[as.size()];//预备接收的String[]
//array = (String[]) o;//只将数组类型进行强转 内部元素存储报错
//应该将内部元素强转后存入新数组
for(int i =0;i<o.length;i++) {
array[i] = (String)o[i];
}
//以上代码可以使用下面两行
// String[] array = new String[as.size()];//预备接收的String[]
// as.toArray(array); //将集合元素 存入参数数组空间中
比较器
对有序集合中的元素进行重新排序 编写比较器 就是编写排序规则
1.针对于 基本基本数据类型和String类型的集合 可以直接使用Collections.sort(集合)进行升序排列
因为已经默认实现了Comparable接口
2.其他自定义类型集合 需要实现比较器后 才可以使用Collections.sort(集合)进行排序
方案一:内部比较器
1.让集合中元素类型(自定义类型)去实现Comparable接口中的compareTo() 编写比较规则
public class User implements Comparable<User> {
public String name;
public int age;
public double score;
public User(String name,int age,double score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age +", score="+score +"]";
}
@Override
public int compareTo(User o) {
// TODO Auto-generated method stub
// //return this.age-o.age; //根据年龄的升序排列 >0 交换 <=0 不动
// 先根据姓名降序排列 姓名相同 根据年龄升序排列
// if(o.name.equals(this.name)) {
// //当姓名相同时 按照年龄升序排列
// return this.age - o.age;
// }
// return o.name.compareTo(this.name);
return o.name.compareTo(this.name);//根据姓名的降序排列
//记忆原则
//this - o 升序
//o - this 降序
//return this.score - o.score>0?1:-1;//根据成绩的升序排列
}
}
2.通过Collections的sort() 对集合进行重新排序
//测试类中
ArrayList<User> au = new ArrayList<User>();
Collections.sort(au);//会自动执行冒泡 调用排序方法compareTo() 两两比较 看是否交换
练习:
1.Book类型 String bookName double price
保存五本书在有序集合中 编写比较器规则 排序后 实现先根据价钱升序 价钱相同 根据书名升序排列输出
2.User类型 String name,int age,Book book三个属性
保存在集合中 排序实现 先按价钱升序排 相同则按年龄降序排 相同则按姓名升序排
保存在集合中 排序实现 先按价钱升序排 价钱相同 按照书名升序 相同则按年龄降序排 相同则按姓名升序排
方案二:外部比较器
1.当一个实体类有多种比较方案时
2.不希望改变javabean (实体类)结构时
1.创建一个类 实现外部比较器接口 Comparator 实现接口方法compare(Object o1, Object o2)
//要比较的实体类
public class Client {
public String name;
public int age;
public Book book;
...
}
//创建外部比较器实现类
public class ClientCom1 implements Comparator<Client> {
@Override
public int compare(Client o1, Client o2) {
// TODO Auto-generated method stub
// 保存在集合中 排序实现 先按价钱升序排 相同则按年龄降序排 相同则按姓名升序排
if (o1.book.price == o2.book.price) {
if (o1.age == o2.age) {
// 价钱和年龄都相同
return o1.name.compareTo(o2.name);
}
// 价钱相同 年龄不同
return o2.age - o1.age;
}
// 价钱不同
// return this.book.price-o.book.price>0?1:-1;
// 调用Book类已经编写好的比较器
return o1.book.compareTo(o2.book);
}
}
2.测试类中 使用Collections的双参sort方法
//测试类调用外部比较器对集合进行排序
ArrayList<Client> au = new ArrayList<Client>();
ClientCom1 cc = new ClientCom1(); //创建外部比较器实现类对象
Collections.sort(au,cc); //调用双参sort方法
//Collections.sort(au,new ClientCom1());
总结:
内部比较器(实体类中实现) Comparable接口–》compareTo(单参实体类类型) Collections.sort(集合)
外部比较器(单独声明类) Comparator接口–》compare(双参实体类类型) Collections.sort(集合,比较器对象)
LinkedList
特点:底层双链结构保存数据 增删快 查询慢
void add(int , E)
void addFirst(E)
void addLast(E)
E get(int)
E getFirst()
E getLast()
E remove(int) 删除某下标元素 并返回这个元素
E removeFirst()
E removeLast()
E set(int,E) 替换 并返回被替换元素
int indexOf(E)
int lastIndexOf(E)