【大数据开发】Java语言基础——Collection、ArrayList、LinkedList、HashSet、TreeSet（Comparable接口和Comparator方法的实现）day15

一、Collection:共性的方法

1. List

存储的对象是有序的(添加对象的顺序和集合存储的顺序是一致的)，且是可以重复的

• ArrayList：后缀是父接口，前缀说的是数据结构
  底层使用的是数组，（内存连续），线程不安全的，便于数据的查找，不便于数据的添加和删除

• Vector: 底层使用的是数组，（内存连续），线程安全的，便于数据的查找，不便于数据的添加和删除

• LinkedList:底层使用的是链表，（内存不连续），不便于数据的查找，便于数据的添加和删除

• Set
  存储的对象是无序的(添加对象的顺序和集合存储的顺序是不一致的)，对象是不可以重复的
  没有特有的功能

• HashSet
  底层数据结构是(链表+数组)–散列表，具备了Set的基本特性（无序，不可重复）
  向集合中添加对象时，先和集合中已有的对象依次比较，先比较哈希值，若哈希值不同，则直接加入链表，如果哈希值相同了，再对两个对象调用equals方法，如果equals方法返回值为true。则认为是相同的对象，不加入集合，如果哈希值不同，直接加入集合
  计算哈希值：

      int hashCode()  
      boolean equals(Object obj)

	哈希值相同不一定是相同的对象
	相同的对象哈希值肯定相同

• TreeSet
  底层数据结构是二叉树，线程不安全的，除了具备Set的基本特性（无序，不可重复），还可以排序
  排序的原理：
  需要加入集合的对象实现了Comparable接口的int compareTo(Object obj)方法。TreeSet只根据compareTo方法的返回值来判断谁大谁小，如果返回值为0，则认为是同一个对象，不加入集合，这也是TreeSet保证对象不重复的方式

import java.util.*;
class Person implements Comparable
{
	public int compareTo(Object obj)
	{
		return 0;
	}
}
class Demo1 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();       //Comparable<? super K> k = (Comparable<? super K>) key;
		//ts.add("hello");//添加的时候就比较大小了
		//ts.add("aaaabbbbbccc");//"aaaabbbbbccc".compareTo("hello")  -6
		//ts.add("zeselkjek");//"zeselkjek".compareTo("aaaabbbbbccc")>0   "zeselkjek".compareTo("hello")>0

		ts.add(new Person());//Person cannot be cast to java.lang.Comparable 因为Person没有实现Comparable接口，所以不能被转成Comparable对象
		ts.add(new Person());//new Person().compareTo(new Person())  返回值为0则认为是同一个对象，不会加入集合
		ts.add(new Person());//

		System.out.println(ts.size());
	}
}

下面来写一个例子，看代码

import java.util.*;
class Student implements Comparable
{
	private String name;
	private int age;

	Student(){}
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}

	public int compareTo(Object obj)  //先按照年龄排序，年龄相同则按照姓名排序（这一段比较重要）
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不对");

		Student stu=(Student)obj;

		int num =this.age-stu.age;

		return num==0?this.name.compareTo(stu.name):num;
		//return 0;
	}

	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public String toString()
	{
		return name+","+age;
	}
}
class Demo2 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi",28));
		ts.add(new Student("zhaosi",26));
		ts.add(new Student("aaaaawangsi",28));
		ts.add(new Student("zhangsan",22));
		ts.add(new Student("jiasi",25));

       //按年龄升序排序

		System.out.println(ts);
	}
}

更改需求，按照姓名排序，那就需要实现Comparator，再新建一个文件

/*
Collection:共性的方法
    List：存储的对象是有序的(添加对象的顺序和集合存储的顺序是一致的)，且是可以重复的
	      ArrayList：后缀是父接口，前缀说的是数据结构
		             底层使用的是数组，（内存连续），线程不安全的，便于数据的查找，不便于数据的添加和删除
		  Vector:   底层使用的是数组，（内存连续），线程安全的，便于数据的查找，不便于数据的添加和删除

		  LinkedList:底层使用的是链表，（内存不连续），不便于数据的查找，便于数据的添加和删除

    Set:存储的对象是无序的(添加对象的顺序和集合存储的顺序是不一致的)，对象是不可以重复的
        没有特有的功能

		  HashSet:底层数据结构是(链表+数组)--散列表，具备了Set的基本特性（无序，不可重复）

		          向集合中添加对象时，先和集合中已有的对象依次比较，先比较哈希值，如果哈希值
				  相同了，再对两个对象调用equals方法，如果equals方法返回值为true。则认为是
				  相同的对象，不加入集合，如果哈希值不同，直接加入集合

				  计算哈希值：int hashCode()  
				  
				              boolean equals(Object obj)

				  哈希值相同不一定是相同的对象
				  相同的对象哈希值肯定相同

          TreeSet: 底层数据结构是二叉树，线程不安全的，除了具备Set的基本特性（无序，不可重复），还可以排序

		           Comparable 排序的原理：需要加入集合的对象实现了Comparable接口的int compareTo(Object obj)方法
				               TreeSet只根据compareTo方法的返回值来判断谁大谁小，如果返回值为0，则认为是
							   同一个对象，不加入集合，这也是TreeSet保证对象不重复的方式

                   Comparator：当类具备的比较大小方式不满足我们的需求时，需要使用这个接口

				              单独使用的接口，可以使用这个接口自定义比较大小的方式
								
							有comparator优先使用comparator
				               
         

*/
import java.util.*;
//按照姓名排序
class CompareByName implements Comparator
{
	public int compare(Object o1, Object o2) 
	{
		if(!(o1 instanceof Student))
			throw new ClassCastException();
		
		if(!(o2 instanceof Student))
			throw new ClassCastException();

		Student stu1=(Student)o1;
		Student stu2=(Student)o2;

		return stu1.getName().compareTo(stu2.getName());
	}
}
class Demo3 
{
	public static void main(String[] args) 
	{
		CompareByName byName=new CompareByName();//创建自定义的比较方式的对象  TreeSet优先使用Comparator的比较方式
		TreeSet ts = new TreeSet(byName);

		ts.add(new Student("lisi",28));
		ts.add(new Student("zhaosi",26));
		ts.add(new Student("aaaaawangsi",28));
		ts.add(new Student("zhangsan",22));
		ts.add(new Student("jiasi",25));
		System.out.println("Hello World!");
	}
}

下面的例子就很明显了

//按字符串的长短，从长到短排序  String已经实现了Comparable接口，是按照字符大小比较的，不符合需求，所以使用Comparator自定义比较方式
import java.util.*;
class ByLength implements Comparator
{
	public int compare(Object obj1,Object obj2)
	{
		if(!(obj1 instanceof String))
			throw new ClassCastException();
		
		if(!(obj2 instanceof String))
			throw new ClassCastException();

		String s1=(String)obj1;
		String s2=(String)obj2;

		return s2.length()-s1.length();

	}
}
class Demo4 
{
	public static void main(String[] args) 
	{
		ByLength length=new ByLength();
		TreeSet ts = new TreeSet(length);
		ts.add("jksdhf");
		ts.add("jksdhfsdfsdfererer");
		ts.add("jksdhfdfsdf");
		ts.add("jk");
		System.out.println(ts);
	}
}

总结