Java_Day_17_总结

根据情况，要实现某一个类中方法时，不想在单独写一个类，或者实现接口在的一个方法时，可以直接写内部类

linkedlist方法：

LinkedList list = new LinkedList();
		// 添加到尾部
		list.add(1);
		list.add(11);
		list.add(12);
		list.add(13);
		// 添加到指定位置
		// list.add(index, element);
		// 添加到头部
		// list.push(e);
		// listaddFirst(e);
		// 尾部添加
		// list.addLast(e);
		// 个数
		System.out.println(list.size());
		// 是否为空
		System.out.print(list.isEmpty());
		// 根据下标删除
		list.remove(0);
		// 根据数据删除
		list.remove(new Integer(11));
		// 清空
		list.clear();
		// 更改
		list.set(2, 111);
		// 获取
		list.get(2);
		// 遍历
		for (Object object : list) {

		}
	}

Set类型：

Set特性无序且不可重复，无序指的是添加顺序和取出顺序不保证一致
HashSet:底层是散列表
TreeSet :底层是红黑树,添加的元素必须按照一定的格式进行排序.
数字:默认从小到大字符串:按每位ASCI码进行排序日期: 自然日期，昨天今天明天..
使用TreeSet的时候，元素必须实现了Comparable接口，因为在添加的时候，
会自动调用该接口的compareTo方法进行比较添加字符串,数字,日期的时候会进行自动排序，是 因为Integer, Str ing, Date都实现了该接口和该方法
 

TreeSet方法：

// 元素添加类型必须一致
		Set set = new TreeSet();
		// 添加
		set.add("j");
		set.add("r");
		set.add("h");
		set.add("w");
		set.add("i");
		// 不可重复，重复不添加
		set.add("j");
		// 移除值
		set.remove("j");
		// 按照每一位的值排序
		set.add("gfktflyfkuyfli");

		// 会排序输出
		System.out.print(set);

使用TreeSet的时候,元素必须实现了Comparable接口，
因为在添加的时候，会自动调用该接口的compareTo方法进行比较添加字符串,数字,日期的时候会进行自动排序，是因为Integer, String, Date都实现了该接口和该方法
 

public class treeSet {
	public static void main(String[] args) {
		TreeSet set = new TreeSet();
		User u1 = new User(51);
		User u2 = new User(7);
		User u3 = new User(208);
		User u4 = new User(1848);
		User u5 = new User(47);
		// set类保证无序，在add时会调用com来确定顺序。自己造的类需要自己覆写
		set.add(u1);
		set.add(u2);
		set.add(u3);
		set.add(u4);
		set.add(u5);
		System.out.println(set);
	}
}

class User implements Comparable {
	// add会根据comparable的返回值来确定添加的位置
	@Override
	public int compareTo(Object o) {
		// this是要添加的元素
		// o是集合中的元素
		if (o instanceof User) {
			User u = (User) o;
			// 升序
			// return this.age - u.age;
			// 降序
			return u.age - this.age;
		}
		// 该方法 返回 0 说明重复,不添加
		// 返回 大于0的值 说明要添加的元素比集合中的大,就往后放
		// 返回 小于0的值 说明要添加的元素比集合中的元素小,就往前放
		return -1;
	}

	int age;

	@Override
	public String toString() {
		return " [" + age + "]";
	}

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

Comparator也是比较器类Comparable也是做比较的,如果这两个同时存在,则Comparator优先级高
Comparable :如果treeSet中保存我们自己定义的类型的时候，使用Comparable
Comparator:如果treeSet中保存的不是我们写的类型的时候就要使用Comparator来指定排序规则
比如Integer默认升序排序，假如我们需要降序排序我们只能使用Comparator,
因为我们不可能去更改Integer的源码
但此时Integer中是有Comparable接口的实现的等于两个比较都存在但是Comparator优先级高,
所以会按照我们定义的规则进行排序
开闭原则:对修改关闭，对扩展开发.
 

public class compator_ {
	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;
	}

}

排序

public class sort_ {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(15);
		list.add(52);
		list.add(35);
		list.add(116);
		// 该方法会调用对象的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;
	}

}