day-17-集合

1 LinkedList

基本使用

 LinkedLis: 底层是一个双向链表，因为不是连续存储  ，只是能够找到下一个元素的地址而已，所以进行添加和删除操作效率较高，但是查询效率较低，因为只能从第一个挨个找

	public static void main(String[] args){
		LinkedList list = new LinkedList();
		//添加到尾部
		list.add(1);
		list.add(2);
		list.add(3);
		//添加到执行位置
		//list.add(index, element);
		//添加到头部
		//list.push(e);
		//list.addFirst(e);
		//尾部添加
		//list.addLast(e);
		//个数
		System.out.println(list.size());
		//是否为空
		System.out.println(list.isEmpty());
		//根据下标删除
		list.remove(1);
		//根据数据删除
		list.remove(new Integer(2));
		//清空
		list.clear();
		//更改
		list.set(0, 9);
		//获取
		list.get(1);
		//遍历
		for(Object object :list){
			
		}
	}

1.2 底层实现 

 1.21 节点类：

        链表由节点构成，因为是双向链表，所以节点有： 保存的数据 Object,        下一个节点对象，节点类型    和上一个节点对象，节点类型 

1.22 LinkedList  类

  为了首位添加效率更高，在LinkedeList中保存了首结点和尾结点

1、23 添加- add

尾添加， if ()else语句

1.24 获取   get 

 先校验下标是否合法，获取数据      if（） else

Get方法只是模拟下标获取的方式而已,本质上就是遍历操作，只不过做了一定的判断,判断找前半截快还是找后半截快

2 Set  和排序

Set特性： 无序且不可重复，无序指的是添加顺序和取出顺序不保证一致
  HashSet： 底层是散列表
  TreeSet： 底层为 红黑树，添加的元素必须按照一定的格式进行排序
                  数字： 默认从小到大
                  字符串：按每位ASCII码 进行排序
                  日期： 自然日期   昨天今天明天
  使用TreeSet 的时候，元素必须实现了Comparable 接口，因为在添加的时候，会自动调用该接口的compareTo方法进行比较
         添加字符串，数字，日期的时候会进行自动排序，是因为Integer,String,Date 都实现了该接口和该方法
        如果我们要存储自定类型的时候，就需要让该类取实现对应的接口和方法才能进行存储

2..1 TreeSet

public static void main(String[] args){
		//创建对象
		TreeSet set = new TreeSet();
		//添加
		set.add(1);
		set.add(2);
		//因为treeSet必须保证元素有序，也就是说元素类型必须统一
		//不统一就没有可比性，就不能排序
		set.add(13);
		set.add(14);
		set.add(15);
		//不可重复 ，重复就不会在添加
		set.add(14);
		System.out.println(set.size());
		System.out.println(set);
		//根据内容删除，不能根据索引删除，因为没有索引
		set.remove(13);
		//遍历
		for(Object object:set){
			System.out.println(object);
		}
		
		set = new TreeSet();
		//是每一位ASCII进行比较
		set.add("aasds");
		set.add("adsds");
		set.add("zsaas");
		set.add("aqe");
		System.out.println(set);
		
		set = new TreeSet();
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("5");
		set.add("6");
		set.add("7");
		set.add("8");
		set.add("9");
		set.add("10");
		System.out.println(set);
	}
	

2.2Comparator

  1) Comparator 也是比较器类   Comparable 也是做比较的，如果这俩个同时存在，则Comparator优先级高
 2)Comparable: 如果 treeSet 中保存我们自己定义的类型的时候 使用Comparable
 3)Comparator:如果 treeSet中保存的不是我们写的类型的时候，就要使用Comparator来指定排序规则

public static void main(String[] args) {
		// 把比较器类的对象传入
//		TreeSet set = new TreeSet(new A());
		// 匿名内部类写法
		TreeSet set = new TreeSet(new Comparator () {
			@Override
			public int compare(Object o1, Object o2) {
				// o1 是要添加的元素
				// o2 是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// 该方法 返回 0 说明重复,不添加
				// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
				// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
				return i2-i1;
			}
		});
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		System.out.println(set);
	}
}
//比较器类
class  A implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		// o1是要添加的元素
		// o2 是集合中的元素
		Integer i1 = (Integer)o1;
		Integer i2 = (Integer)o2;
		// 该方法 返回 0 说明重复,不添加
		// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
		// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
		return  i2-i1;
	}
	
}

2.3 List 排序

        

package TTest;

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

public class Collection_07 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(1);
		list.add(22);
		list.add(3);
		list.add(11);
		// 该方法会调用对象的Comparable中的compareTo方法或者是Comparator接口中的方法
		// 因为Integer中有compareTo方法,而且是升序,所以才可以使用sort方法
		// 比如想要降序可以使用sort方法重载
		// Collections.sort(list);
		Collections.sort(list, new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				// o1 是要添加的元素
				// o2 是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// 该方法 返回 0 说明重复,不添加
				// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
				// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
				return i2 - i1;
			}
		});
		System.out.println(list);

		list = new ArrayList();
		list.add(new Student1(18));
		list.add(new Student1(11));
		list.add(new Student1(15));
		list.add(new Student1(4));
		// 因为Student1没有实现comparable接口 所以不能使用sort方法
		// Collections.sort(list);
		// 但是可以使用重载的方法
		Collections.sort(list,new Comparator () {
			@Override
			public int compare(Object o1, Object o2) {
				return 0;
			}
		});
	}
}

class Student1 {
	int age;

	public Student1(int age) {
		super();
		this.age = age;
	}

}

2.4总结

 Comparable： 如果 treeSet 中保存我们自己定义的类型的时候，使用 Comparable

Comparator:  如果treeSet 中保存的不是我们写的类型的时候，就要使用Comparator 来指定排序规则

比如 Integer 默认是升序排序,假如我们需要降序排序,我们只能使用 Comparator,因为我们不可能去更改Integer的源码

     但此时 Integer中是有Comparable接口的实现的,等于两个比较都存在,但是Comparator优先级高,

      所以会按照我们定义的规则进行排序

      开闭原则 : 对修改关闭,对扩展开发