java第14天----集合中的List，Set

昨天知识总结

• 1.Date
• 2.DateFormat
• 3.Math/Random
• 4.修饰词
• 5.集合
  • 集合与数组的区别
  • 集合的分类
  • Collection方法
  • List，Set对比

集合

List

• List特有方法（可以操作下标）
• 存储的数据是有序的（元素的顺序与添加元素的顺序一致），可以重复的

public class Test {
	public static void main(String[] args) {
		//* List：特有方法，可以操作下标
		List list = new ArrayList<>();
		
				//1.增：
				//void add(int index, E element)
		list.add("java");
		list.add(0,"python");
		list.add("html");
		list.add("java1");
		list.add("BigData");
		System.out.println(list);
				//boolean addAll(int index, Collection<? extends E> c) 

				//2.删
				//E remove(int index) 这里可以将e暂时理解成object
		System.out.println(list.remove(0));
		System.out.println(list);

				//3.改
			    //E set(int index, E element)
		System.out.println(list.set(0, "ios"));

				//4.查
			     //ListIterator<E> listIterator(int index) 
			     //List<E> subList(int fromIndex, int toIndex)
		List list2 = list.subList(1, 3);
		System.out.println(list2);
			     //E get(int index)
		System.out.println(list.get(0));
				     
				//5.删除全部对象
		list.clear();
	}

}

迭代器(遍历)

	//ListIterator<E> listIterator() 
	//返回此列表元素的列表迭代器（按适当顺序）。
	public static void test(List list) {
		//获取迭代器对象
		ListIterator iterator = list.listIterator();
		while(iterator.hasNext()) {
			Object object = (Object) iterator.next();
			System.out.println("从左到右："+object);
		}
		
		
		//从右到左
		while(iterator.hasPrevious()) {
			Object object = iterator.previous();
			System.out.println("从右到左"+object);
		}
		
		//注意事项：
		while(iterator.hasNext()) {
			Object object = (Object) iterator.next();
			System.out.println("从左到右："+object);
			
			//需求：将list中的html删除
			if(object.equals("html")) {
				//在使用迭代器遍历结合期间，使用它list的删除方法直接删除元素，有可能产生错误，所以不要这样删
				//使用迭代器自带的方法进行删除
				//list.remove("html");
				//注意：在listiterator中包含remove，set，add方法，但是最好不要同时使用
				iterator.remove();
				//iterator.add(e);
				//iterator.set(e);
			}
		}
	}

实例

• 实例：list特点是有序的，可以重复的
• 要求：使用list存储数据，但是不能重复?----利用contains方法

public class Test {
   public static void main(String[] args) {
   	ArrayList arrayList = new ArrayList<>();
   	arrayList.add("java1");
   	arrayList.add("java2");
   	arrayList.add("java2");
   	arrayList.add("java3");
   	arrayList.add("java4");
   	arrayList.add("java5");
   	System.out.println(arrayList);
   	
   	//创建一个临时的集合用于存储不重复的元素
   	ArrayList arrayList2 = new ArrayList<>();
   	
   	
   	//遍历元素集合
   	Iterator iterator = arrayList.iterator();
   	while(iterator.hasNext()) {
   		Object object = (Object) iterator.next();
   		String string = (String)object;
   		//如果新的集合中不包含当前的元素，就将当前的元素添加进去
   		/*
   		 * 原理：在添加新元素的时候，返回调用元素的equals方法，去比较，所有的都返回false，整体认为是false，有一次比较
   		 * 返回true，整个contains的结果就是true
   		 * 
   		 * 添加第三个元素的过程：
   		 * 第三个元素。equals（"java"） = false 据许碧	第三个元素.equals（”java2“） = true   停止比较
   		 */
   		
   		if(!arrayList2.contains(string)) {
   			arrayList2.add(string);
   		}
   	}
   	System.out.println(arrayList2);
   }
}

Vactor

• Vector:底层的数据结构是数组，线程安全的，特点：查找速度快，添加删除速度慢
• 不同点：遍历的时候使用的是枚举器

public class Test {
	public static void main(String[] args) {
		//Vector:了解
		//不同点：遍历的时候使用的是枚举器
		
		//创建存值
		Vector vector = new Vector<>();
		vector.add("java1");
		vector.add("java2");
		vector.add("java3");
		vector.add("java4");
		System.out.println(vector);
		
		
		Enumeration enumeration = vector.elements();
		//遍历
		while (enumeration.hasMoreElements()) {
			Object object = (Object) enumeration.nextElement();
			System.out.println(object);
			
		}
	}
}

LinkedList

• LinkedList:底层数据结构式链表，线程不安全的，特点：查找速度慢，添加删除速度快
• 特有方法

public class Test {
	public static void main(String[] args) {
//		LindedList
		LinkedList linkedList = new LinkedList<>();
//		特有的方法：

//		addFirst()//始终在首位添加
//		addLast()//始终在末尾添加
		linkedList.addFirst("java");
		linkedList.addLast("python");
		linkedList.add("ios");
		linkedList.add(1,"html");
		linkedList.addFirst("BigData");
		System.out.println(linkedList);
//		getFirst()//获取的对象不存在会发生异常
//		getLast()
		System.out.println(linkedList.getFirst());
//
//		removeFirst()//删除的对象不存在会发生异常
//		removeLast()
		System.out.println(linkedList.removeFirst());
//
//		从jdk1.6开始出现以下方法
//		offerFirst()
//		offerLast()
		linkedList.clear();
//
//		peekFirst()//获取的对象不存在会返回null
//		peekLast()
		System.out.println(linkedList.peekFirst());
//
//		pollFirst()//删除的对象不存在会返回null
//		pollLast(
		System.out.println(linkedList.pollFirst());
	}
}

Set

• Set:无序的，不可重复的

HashSet

• HashSet：底层是哈希表，线程不安全的
• HashSet实现去重的方法：是通过调用元素内部的HashCode和equals方法去实现的，首先会调用HashCode方法，比较两个元素的哈希码值，如果哈希码值不同直接认为是两个对象，停止比较，如果相同，再去使用equals比较，返回true认为是一个对象，返回false认为是两个对象。
• 总结：
  • 1.hashSet只能实现去重，不能排序
  • 2.对于自定义的类要想按照自己制定的规则去重，必须重写hashCode和quals方法。在String中是重写了hashCode方法，所以可以保证进行比较的时候，比较的是内容

public class Test {
	public static void main(String[] args) {
			HashSet set = new HashSet<>();
		//在add内部实现去重的功能，默认调用字符串的hashCode和equals方法。
		//在String中是重写了hashCode和equals方法，所以可以保证进行比较的时候，比较的是内容
		set.add("java1");
		set.add("java4");
		set.add("java2");
		set.add("java5");
		set.add("java2");
		System.out.println(set);
		
		//
		HashSet set1 = new HashSet<>();
		set1.add(new Person1("bingbing1",18));
		set1.add(new Person1("bingbing2",18));
		set1.add(new Person1("bingbing3",183));
		set1.add(new Person1("bingbing3",183));
		set1.add(new Person1("bingbing4",186));
		System.out.println(set);
	}
}
class Person1{
	String name;
	int age;
	public Person1(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name="+name+",age"+age+"]";
	}
	//重写hashCode方法
		@Override
		public int hashCode() {
			// TODO Auto-generated method stub
			return name.hashCode()+age*1000;
		}
	//重写equals方法，制定自己的比较规则：只要年龄和姓名相同就认为是同一个人
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(!(obj instanceof Person1)) {
			throw new ClassCastException();
		}
		Person1 person = (Person1)obj;
		return (name.equals(person.name)&&age == person.age);
	}
}

TreeSet

• TreeSet：底层是二叉树，线程不安全的
  
  
• TreeSet：实现去重和排序的方式 ------ 默认排序
  • 1.让元素去实现Comparable接口，重写compareTo方法
  • 2.创建比较器类，让它实现Comparetor接口，重写compare方法，再将比较器类作用于TreeSet。内部的元素会按照比较器进行比较-----人工排序
• 总结：对TreeSet排序有两种方式，一种默认排序（系统排序），一种是人工排序
• 注意：人工排序的优先级高于默认排序

实现Comparable接口

public class Demo10 {
	public static void main(String[] args) {
		//*1.让元素去实现Comparable接口，重写compareTo方法
		TreeSet set = new TreeSet<>();
		//使用TreeSet在存储字符串的时候自动实现了排序和去重
		//因为在add方法中调用了Comparable接口的compareTo方法
		//默认是按照升序字典顺序排序
		set.add("java1");
		set.add("java4");
		set.add("java2"); 
		set.add("java5");
		set.add("java2");
		System.out.println(set);
		TreeSet set1 = new TreeSet<>();
		set1.add(new Person2("bingbing1",18));
		set1.add(new Person2("bingbing2",18));
		set1.add(new Person2("bingbing3",183));
		set1.add(new Person2("bingbing3",183));
		set1.add(new Person2("bingbing4",186));
		System.out.println(set1);
	}
}
class Person2 implements Comparable{
	String name;
	int age;
	public Person2(String name,int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name="+name+",age"+age+"]";
	}
	
	//重写equals方法，制定自己的比较规则：只要年龄和姓名相同就认为是同一个人
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(!(obj instanceof Person2)) {
			throw new ClassCastException();
		}
		Person2 person = (Person2)obj;
		return (name.equals(person.name)&&age == person.age);
	}
	@Override
	//自己制定的规则，按照年龄和姓名比较
	//返回负数前面比后面小，返回正数说明前面比后面大，返回0表示相同
	public int compareTo(Object o) {
		if(!(o instanceof Person2)) {
			throw new ClassCastException();
		}
		//先按照年龄比较，年龄相同再去比姓名
		Person2 person2 = (Person2)o;
		int num = age-person2.age;
		return num == 0? name.compareTo(person2.name):num;
	}
}

比较器实现Comparator接口

• 2.创建比较器类，让它实现Comparetor接口，重写compare方法，再讲比较器类作用于TreeSet，内部的元素会按照比较器类进行比较。内部远的元素会按照比较器进行比较-----人工排序
• 实例：要求按照字符串的长度对字符串进行排序----从长到短
• 步骤：
  • 1.创建比较器类实现Compartor接口，重写compare方法
  • 2.创建比较器对象,并指定给存储元素的TreeSet

public class Demo11 {
	public static void main(String[] args) {
		ComWithLength comWithLength = new ComWithLength();
		TreeSet set = new TreeSet<>(comWithLength);
		//使用TreeSet在存储字符串的时候自动实现了排序和去重

		set.add("java111111111");
		set.add("java422");
		set.add("java2456"); 
		set.add("java523535");
		set.add("java2456");
		System.out.println(set);
	}
}
//1.创建比较器类实现Compartor接口，重写compare方法
class ComWithLength implements Comparator{
	@Override
	public int compare(Object o1, Object o2) {
		if(!(o1 instanceof String)) {
			throw new ClassCastException();
		}
		if(!(o2 instanceof String)) {
			throw new ClassCastException();
		}
		String s1 = (String)o1;
		String s2 = (String)o2;
		
		int num = s1.length() - s2.length();
		return num == 0?s1.compareTo(s2):num;
	}
}