黑马程序员-集合篇（2）

最新推荐文章于 2024-10-12 22:35:37 发布

xinchi500

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量229

点赞数

文章标签： java 集合

本文链接：https://blog.csdn.net/xinchi500/article/details/48729263

版权

Set

------- android培训、 java培训、期待与您交流！---------

Set:元素是无序的(存入和取出的顺序不一定一致)，元素不可以重复

|--HashSet:底层数据结构是哈希表

HashSet是如何保证元素唯一性的呢？

是通过元素的两个方法，hashCode和equals来完成的

如果元素的HashCode值相同，才会判断equals是否为true.

如果元素的hashCode值不同，不会调用equals.

注意：判断两个元素是否相同，或者删除元素等操作，都是依据元素的hashCode和equals方法

Set集合的功能和Collection是一致的

例一

import java.util.*;
class  HashSetDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();//创建一个HashSet集合

		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		sop(hs.add("java01"))//返回false;

		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

例二

往hashSet集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素

import java.util.*;
class HashSetTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();

		hs.add(new Person("zhangsan",20));//hs.add(Object obj);相当于Object obj=new Person("zhangsan",20)),类型提升，
		hs.add(new Person("lisi",25));
		hs.add(new Person("wangwu",26));
		hs.add(new Person("zhaoliu",28));
		hs.add(new Person("zhaoliu",28));

		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			Person p=(Person)obj;//如果要子类对象特有方法的时候必须向下转型
			sop(p.getName()+"....."+p.getAge());
		}
	}
}
class Person
{
	String name;
	int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int hashCode()//调用hashCode是为了让主函数调用equals方法
	{	
		System.out.println(this.name+".....hashCode");
		return name.hashCode()+age*15;
	}
	public boolean equals(Object obj)//复写equals方法
	{
		if(!(obj instanceof Person))//判断obj是否属于Person类
			return false;
		Person p=(Person)obj;//如果属于Person就把object向下转型，让person拥有equals方法
		System.out.println(this.name+"...equal..."+p.name);
		return this.name.equals(p.name)&&this.age==p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

TreeSet

TreeSet特点:

可以对set集合中的元素进行排序

底层数据结构是二叉树

保证元素唯一的依据

compareTo方法return 0;

1、TreeSet排序的第一种方式：让元素自身具有比较性。

元素需要实现 Comparable接口，覆盖 compareTo方法

这种方式也称为元素的自然排序，或者叫做默认排序。

2、TreeSet的第二种方式

当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时

就需要让集合自身具备比较性。

定义类实现Comparetor接口，覆盖compare方法。

在集合初始化是就有了比较方式。

import java.util.*;
//按照字符串长度进行排序
class  TreeSetTest
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet(new MyCompara());

		ts.add("abc");
		ts.add("sa");
		ts.add("dddv");
		ts.add("abkjc");
		ts.add("abcjjnmn");
		ts.add("ab");

		Iterator it= ts.iterator();

		while (it.hasNext())
		{
			sop(it.next());
		}
	}
}
class MyCompara implements Comparator//实现<span style="font-family: 微软雅黑;">Comparator接口，复写compare方法
</span>{
	public int compare(Object o1,Object o2)
	{
		String s1=(String)o1;
		String s2=(String)o2;
		int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));		
		if (num==0)
			return s1.compareTo(s2);
		return num;
	}
}

泛型

用于解决安全问题，是一个类型安全机制。

好处：

1.将运行时期出现的问题ClassCastException，转移到了编译时期，

方便于程序解决问题。让运行问题减少，安全

2.避免了强制转换麻烦。

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候

早期定义object来完成扩展

现在定义泛型来完成扩展。

泛型类定义的泛型，在整个类中有效，如果被方法调用

那么泛型的对象明确要操作的具体类型后，所有要操作的类型就已经固定了

class Demo<T>
{
	public void show(T t)
	{
		System.out.println(t);
	}
	public void print(T t)
	{
		System.out.println(t);
	}
	
}

为了让不同方法可以操作不同的类型，而且类型还不确定

那么类型可以定义在方法上

class Demo
{
	public<T>void show(T t)
	{
		System.out.println(t);
	}
	public<T>void print(T t)
	{
		System.out.println(t);
	}
}

在类和方法上同时定义泛型

class Demo<T>
{
	public void show(T t)
	{
		System.out.println(t);
	}
	public<Q>void print(Q t)
	{
		System.out.println(t);
	}
}

泛型定义在接口上

interface inter<T>
{
	public void show(T t);
}
class Demo<T> implements inter<T>
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
}
class  GenericDemo3
{
	public static void main(String[] args) 
	{
		Demo<Integer> d=new Demo<Integer>();
		d.show(5);
	}
}

？：通位符

泛型限定：

？extends E: 可以接受E类型或者子类型，上限

？super E : 可以接受E类型或者E的父类型。下限

import java.util.*;
class GenericDemo4 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		TreeSet<Student> al=new TreeSet<Student>(new Comp());//创建学生类的TreeSet集合对象

		al.add(new Student("lisa",15));//向集合中添加Student对象
		al.add(new Student("lili",17));
		al.add(new Student("liai",18));
		al.add(new Student("meimei",19));
		 
		Iterator<Student> it =al.iterator();
		while(it.hasNext())
		{	
			Student s=it.next();
			sop(s.getName()+"..."+s.getAge());
			
		}
	        TreeSet<Worker> al1=new TreeSet<Worker>(new Comp());

		al1.add(new Worker("5lisa",5));//向集合中添加一个Worker对象
		al1.add(new Worker("5lili",7));
		al1.add(new Worker("5liai",8));
		al1.add(new Worker("5meimei",9));

		Iterator<Worker> it1 =al1.iterator();
		while(it1.hasNext())
		{	
			Worker w=it1.next();
			sop(w.getName()+"..."+w.getAge());
			
		}
	}	
}
class Comp implements Comparator<Person>//实现Comparator接口，复写compare()方法，让学生自身具备比较方法
{
	public int compare(Person p1,Person p2)
	{
		int num=p1.getName().compareTo(p2.getName());//先根据姓名比较，后比较年龄
			if(num==0)
			return new Integer(p1.age).compareTo(new Integer(p2.age));
			return num;
	}
}
class Person//创建Person类，让Person有姓名和年龄的属性
{
	 String name;
	 int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);		
	}
	public void show()
	{
		System.out.println(4);
	}
}
class Worker extends Person
{
	Worker(String name,int age)
	{
		super(name,age);
	}
}

------- android培训、 java培训、期待与您交流！---------