12.有序集合

有序集合

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)