集合框架之set集合

1.集合框架set集合框架Set（HashSet哈希表存储、重复元素存储底层探究）

Set存储的元素是无序的，不可重复
无序性不等于随机性 添加set所在类必须重写equls和hashCode方法 。
保证Set的不可重复。Set元素中的存储采用了哈希算法。

// * 1.set集合不能存放重复元素的问题 2、HashSet哈希表存储、重复元素存储底层探究
 *      不能存放重复元素   字符串、八大基本数据类型
 *      set集合的元素是无序的


	 public class setDemo {
      public static void main(String[] args) {
       Set set=new HashSet<>();
       set.add( "wanting");
       set.add("zhuangyuan");
       set.add("runchen");
       set.add("xiang");
       set.add("wanting");
       System.out.println(set.size());
	}
}

在这里插入图片描述

  • 由此论证Set集合不能存放重复元素

2、Hash哈希存储、重复元素存储底层探

  •  list.contains    底层调用eqluals方法

  •  sat.add          底层调用了hashCode/equals


```javascript

public class setDemo {
      public static void main(String[] args) {
       Set set=new HashSet<>();
       set.add(new Person("wanting",18,1500));
       set.add(new Person("zhuangyuan",18,500));
       set.add(new Person("runchen",18,1200));
       set.add(new Person("xiang",22,2500));
       set.add(new Person("wanting",18,1500));
       System.out.println(set.size());
       Iterator it=set.iterator();
       while (it.hasNext()) {
		System.out.println(it.next());
	}
	}
}

class Person{
	private String name;
	private int age;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public int hashCode() {
//           System.out.println("hashCode-----------"+this.name);
           int code= this.name.hashCode()+this.age;
//           System.out.println(code);
		   return code;
	}

在这里插入图片描述

  • set集合中的元素是无序的（存入和取出的顺序不一定一致）
  • 说明set重复只限于只限对于字符串、八大基本数据类型

但equls与hashCodo同时运行

@Override
	public int hashCode() {
           System.out.println("hashCode-----------"+this.name);
//           int code= this.name.hashCode()+this.age;
//           System.out.println(code);
		   return super.hashCode();
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals---------");
		return super.equals(obj);

在这里插入图片描述
是因为这里的返回的hashCode每一次都不同

@Override
	public int hashCode() {
           System.out.println("hashCode-----------");
           int code= this.name.hashCode()+this.age;
           System.out.println(code);
		   return code;
	}

在这里插入图片描述

  • 可以得出结论：hashCodo与equals方法来完成；如果hashCode值相同，才会判断equals是否为true；如果hashCode值不同，那么不会调用equals。

2、集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）

/**
   * 2、集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
  
   *     java.lang.ClassCastException:
   *         com.zking.set.Person connot be cast to java.lang.Comparable
   * @author 96345
   *
   */

package com.zking.list;

import java.util.TreeSet;


public class TreeSetDemo {
   public static void main(String[] args) {
	 TreeSet set= new TreeSet();
	 set.add(26);
	 set.add(25);
	 set.add(28);
	 set.add(21);
	 set.add(31);
	 System.out.println(set);
}
}

class Person{
	private String name;
	private int age;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	
	
}

在这里插入图片描述

  • 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的 自然排序（元素自身具有比较性）

2.1自然排序

public class TreeSetDemo {
   public static void main(String[] args) {
	 TreeSet set= new TreeSet();
	     set.add("ab");
	    set.add("cd");
	    set.add("ef");
	  System.out.println(set);
	}
}
}

运行结果：
在这里插入图片描述

package com.zking.list;

import java.util.Iterator;
import java.util.TreeSet;

/**
   * 2、集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
   * 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的     自然排序（元素自身具有比较性）
   *     java.lang.ClassCastException:
   *         com.zking.set.Person connot be cast to java.lang.Comparable
   * @author 96345
   *
   */
public class TreeSetDemo {
   public static void main(String[] args) {
	 TreeSet set= new TreeSet();
	  set.add(new Person("wanting",18,1500));
      set.add(new Person("zhuangyuan",23,500));
      set.add(new Person("runchen",19,1200));
      set.add(new Person("xiang",22,2500));
      set.add(new Person("wantings",88,1500));
//	  System.out.println(set);
	  Iterator it=set.iterator();
	  while (it.hasNext()) {
		  System.out.println(it.next());
	}
}
}
   /**
    * 年少有为
    * @author 96345
    *
    */
    class Personns implements Comparable<Person>{
    	public int compare(Person o1, Person o2) {
    		int num=o1.getAge()-o2.getAge();//年轻
    		if(num==0) {
    			return o2.getMoney()-o1.getMoney();//有为钱多
    		}
    			return num;
    		}

		@Override
		public int compareTo(Person o) {
			// TODO Auto-generated method stub
			return 0;
		}
    }
class Person {
	private String name;
	private int age;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public int hashCode() {
		System.out.println("hashCode----"+this.name);
		int code=this.name.hashCode()+this.age;//算一个name和age的哈希码值的和
		System.out.println(code);
		return code;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals---");
        Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age;
	}
	/**
	 * 让元素具有比较性
	 * 在做自然排序方法重写时，一定先判断主要条件、还要判断次要条件
	 * **/
//	@Override
//	public int compareTo(Person o) {
//		int num=o.money-this.age;
//		if (num==0) {
//			return o.age-this.age;
//		}
//		return num;
//	}
	
	
}

我们存放的是乱序的，取出来的时候进行了排序

引用数据类型想要排序，必须实现Comparable接口，否则会出现错（java.lang.ClassCastException: com.javaxl.Peroon cannot be cast to java.lang.Comparable）
在这里插入图片描述

2.2、TreeSet数据结构（二叉树）

可以对set集合进行排序，底层数据结构是二叉树；

保证元素唯一性的依据是，compareTo方法return 0

 

所以

注意：TreeSet排序的第一种方式，让元素自身具有比较性；

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

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

package com.zking.list;

import java.util.Iterator;
import java.util.TreeSet;

/**
   * 2、集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
   * 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的     自然排序（元素自身具有比较性）
   *     java.lang.ClassCastException:
   *         com.zking.set.Person connot be cast to java.lang.Comparable
   * @author 96345
   *
   */
public class TreeSetDemo {
   public static void main(String[] args) {
	 TreeSet set= new TreeSet();
	  set.add(new Person("wanting",18,1500));
      set.add(new Person("zhuangyuan",23,500));
      set.add(new Person("runchen",19,1200));
      set.add(new Person("xiang",22,2500));
      set.add(new Person("wantings",88,1500));
	  System.out.println(set);
	  Iterator it=set.iterator();
	  while (it.hasNext()) {
		  System.out.println(it.next());
	}
}
}

class Person implements Comparable<Person>{
	private String name;
	private int age;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	
	@Override
	public boolean equals(Object obj) {
        Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age;
	}
	/**
	 * 让元素具有比较性
	 * 在做自然排序方法重写时，一定先判断主要条件、还要判断次要条件
	 * **/
	@Override
	public int compareTo(Person o) {
		int num=o.money-this.age;
		if (num==0) {
			return o.age-this.age;
		}
		return num;
	}
	
	
}

在这里插入图片描述

比较器排序（用于应对某些代码频繁修改所带来不便情况）
通过实现Comparator来完成（调用不同的方法来完成）不需要每次都修改代码，也可以实现方法回滚
TreeSet比较器排序
TreeSet排序的第二种方式
当元素自身不具备比较性时，或者具备的比较性不是所需要的；
注意：这时需要让集合自身具备比较性
在集合初始化时，就有了比较方式；
定义一个类，实现comparator接口，实现compare方法
当两种排序都存在时，比较器排序优先级更高

找集合中年少有为的男人

package com.zking.list;
mport java.util.Iterator;
import java.util.TreeSet;

/**
   * 2、集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
   * 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的     自然排序（元素自身具有比较性）
   *     java.lang.ClassCastException:
   *         com.zking.set.Person connot be cast to java.lang.Comparable
   * @author 96345
   *
   */
public class TreeSetDemo {
   public static void main(String[] args) {
	 TreeSet set= new TreeSet();
	  set.add(new Person("wanting",18,1500));
      set.add(new Person("zhuangyuan",23,500));
      set.add(new Person("runchen",19,1200));
      set.add(new Person("xiang",22,2500));
      set.add(new Person("wantings",88,1500));
//	  System.out.println(set);
	  Iterator it=set.iterator();
	  while (it.hasNext()) {
		  System.out.println(it.next());
	}
}
}
   /**
    * 年少有为
    * @author 96345
    *
    */
    class Personns implements Comparable<Person>{
    	public int compare(Person o1, Person o2) {
    		int num=o1.getAge()-o2.getAge();//年轻
    		if(num==0) {
    			return o2.getMoney()-o1.getMoney();//有为钱多
    		}
    			return num;
    		}

		@Override
		public int compareTo(Person o) {
			// TODO Auto-generated method stub
			return 0;
		}
    }
class Person implements Comparable<Person>{
	private String name;
	private int age;
	private int money;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public int hashCode() {
		System.out.println("hashCode----"+this.name);
		int code=this.name.hashCode()+this.age;//算一个name和age的哈希码值的和
		System.out.println(code);
		return code;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals---");
        Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age;
	}
	/**
	 * 让元素具有比较性
	 * 在做自然排序方法重写时，一定先判断主要条件、还要判断次要条件
	 * **/
	@Override
	public int compare(Person o1, Person o2) {
		int num=o2.getMoney()-o1.getMoney();
		if(num==0) {
			return o1.getAge()-o2.getAge();
		}
		return num;
	}

	
}


 泛 型
  • 好处/为什么出现？
  •   不使用泛型的情况下，会将未知的错误表现在运行时期

  •   如果说用代码去处理了，这个可能发现的错误，那么运行时期的错误就不会暴露处理
  • 1、讲运行期的异常转换成编译期的错误，让程序员更早的发现，从而解决代码隐患
  • 2、提高了代码健壮性
  • 泛型类
  • 泛型接口
  • 泛型方法
public class FanXinDemo {
  public static void main(String[] args) {
	List<Integer> c=new ArrayList();
	c.add(22);
	c.add(23);
	c.add(26);
	c.add(28);
	c.add(55);
	//c.add("s")
	//ctrl+shift+o  快速导包
	Iterator it=c.iterator();
	while (it.hasNext()) {
		Object obj=it.next();
		int num=(int) obj;
		if (num % 2==0) {
			System.out.println(num);
		}
	}
 }
}
/**javascript
 * 购物车项目
 * 订单模块，用户模块、商品模块
 * Class OrderDao{
 * public List<Order> list(Order order){
 * 
 * }
 * 
 * public int add(Order order){}
 * public int edit(Order order){}
 * public int del(Order order){}
 * 
 * }
 * 
 * Class UserDao{
 * public List<Order> list(Order order){
 * public int add(User User){}
 * public int edit(User User){}
 * public int del(User User){}
 * }
 * 
 * Class ProductDao{
 * public List<Order> list(Order order){
 * public int add(User User){}
 * public int edit(User User){}
 * public int del(User User){}
 * }
 * 
 * }
 * -----不使用泛型的情况-----------
 * -----使用泛型的情况-----------
 *  Class ProductDao{
 * public List<T> list(T t){
 * public int add(T t){}
 * public int edit(T t){}
 * public int del(T t){}
 * }
 * Class OrderDao extends BaseDao<order>{}
 *  Class OrderDao extends BaseDao<order>{}
 *   Class OrderDao extends BaseDao<order>{}
 * */
版权声明：本文为weixin_44222931原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。